Logica booleana

La logica booleana è un sistema di logica che si occupa di valori veri e falsi. Nella programmazione, la logica booleana viene ampiamente utilizzata per prendere decisioni e controllare il flusso di un programma.

I tre operatori logici principali nella logica booleana sono AND, OR e NOT.

• AND : L'operatore AND restituisce vero solo se entrambi gli operandi sono veri.
• OR : L'operatore OR restituisce vero se uno o entrambi gli operandi sono veri.
• NOT : L'operatore NOT restituisce l'opposto di un dato operando.

Operatori logici nel codice

JavaScript ha tre operatori logici: &&(AND), ||(OR) e !(NOT). Questi operatori sono spesso usati per combinare e manipolare valori booleani in JavaScript.

Operatore && (AND).

L' &&operatore restituisce truese entrambi gli operandi sono truee falsein caso contrario. Ecco alcuni esempi:

// Normal examples
console.log(true && true);   // true
console.log(true && false);  // false
console.log(false && true);  // false
console.log(false && false); // false

// Type coercion examples
console.log("hello" && 42);   // 42
console.log("" && 42);       // ""

• L' &&operatore è noto come operatore di cortocircuito perché valuta il secondo operando solo se il primo operando è vero. Questo può essere utile per ottimizzare il codice ed evitare errori.

L' ||operatore restituisce truese almeno uno degli operandi è truee falsein caso contrario. Ecco alcuni esempi:

// Normal examples
console.log(true || true);   // true
console.log(true || false);  // true
console.log(false || true);  // true
console.log(false || false); // false

// Type coercion examples
console.log("" || "hello");  // "hello"
console.log(0 || 42);        // 42

• L' ||operatore è anche un operatore di cortocircuito, valutando il secondo operando solo se il primo operando è falso.
• L' ||operatore viene spesso utilizzato per fornire valori predefiniti per le variabili, come in const value = input || defaultValue;.

L' !operatore nega un valore booleano, restituendo truese l'operando è falsee falsese l'operando è true. Ecco alcuni esempi:

// Normal examples
console.log(!true);  // false
console.log(!false); // true

// Type coercion examples
console.log(!"hello");   // false
console.log(!undefined); // true

• L' !operatore può essere utilizzato per convertire un valore in un tipo booleano negandolo due volte, come in !!value.

L'ordine degli operatori logici

L'ordine degli operatori logici può fare la differenza in alcuni casi in cui è necessario valutare più condizioni. Ecco alcuni esempi:

Precedenza dell'operatore: L'AND logico ( &&) ha una precedenza maggiore dell'OR logico ( ||). Ciò significa che &&viene valutato prima ||e può modificare l'esito di una condizione. Per esempio:

// This condition will evaluate to true
if (true || false && true) {
  // do something
}
// This condition will evaluate to false
if ((true || false) && true) {
  // do something
}

Nel secondo esempio, (true || false)viene valutato per primo, che risulta in true. Quindi true && trueviene valutato, che risulta in true. Anche l'intera condizione è vera, ma viene valutata in modo diverso a causa delle parentesi.

Valutazione del cortocircuito: l'AND logico ( &&) e l'OR logico ( ||) utilizzano la valutazione del cortocircuito, il che significa che il secondo operando viene valutato solo se necessario. Per esempio:

// This condition will evaluate to true without an error
if (x !== null && x.property === "value") {
  // do something
}
// This condition will throw an error
if (x.property === "value" && x !== null) {
  // do something
}

Nel secondo esempio, if xis null, x.propertygenererà un errore perché nullnon ha alcuna proprietà. Il secondo operando viene valutato prima del primo operando, il che può causare errori se non utilizzato con attenzione.

Negazione: il NOT logico ( !) può cambiare il risultato di una condizione negandola. Per esempio:

let x = true;

// This condition will evaluate to false
if (!x) {
  // do something
}
// This condition will evaluate to true
if (!!x) {
  // do something
}

Come principiante, è importante prestare attenzione all'ordine degli operatori logici e utilizzare le parentesi per chiarire l'ordine, se necessario. È anche importante comprendere la valutazione dei cortocircuiti e come può prevenire gli errori. La negazione dovrebbe essere usata con cautela perché può rendere le condizioni più difficili da leggere e comprendere.

Esempi del mondo reale

Ecco alcuni esempi realistici di operatori logici utilizzati nel codice. Leggi gli esempi e vedi se riesci a capire la logica, ma non scoraggiarti se non puoi perché non abbiamo ancora discusso delle funzioni!

Convalida dell'input dell'utente:

function validateInput(input) {
  const isString = typeof input === 'string';
  const isNotEmpty = input !== '';
  const isLessThanTenChars = input.length < 10;
  return isString && isNotEmpty && isLessThanTenChars;
}

function filterProducts(products, minPrice, maxPrice, availableOnly) {
  return products.filter(product => {
    const isWithinPriceRange = product.price >= minPrice && product.price <= maxPrice;
    const isAvailable = availableOnly ? product.stock > 0 : true;
    return isWithinPriceRange && isAvailable;
  });
}

function isEligibleForDiscount(user) {
  const hasPaid = user.orders.some(order => order.status === 'paid');
  const hasFrequentOrders = user.orders.length >= 5;
  const hasValidCoupon = user.coupons.includes('DISCOUNT2022');
  return (hasPaid || hasFrequentOrders) && hasValidCoupon;
}

function isProductOnSale(product) {
  const isDiscounted = product.discount > 0;
  const hasLowStock = product.stock <= 10;
  return isDiscounted || hasLowStock;
}

function getTaskStatus(priority, isComplete) {
  const isUrgent = priority === 'high' || priority === 'urgent';
  const isOverdue = priority === 'low' && !isComplete;
  const isInProgress = priority === 'medium' && !isComplete;
   if (isUrgent) {
      return 'Urgent';
    } else if (isOverdue) {
      return 'Overdue';
    } else if (isInProgress) {
      return 'In Progress';
    } else {
      return 'Pending';
   }
}