La logica è il fondamento di qualsiasi programma, quindi ti consigliamo di padroneggiare gli operatori logici per strutturare il tuo codice in modo efficiente.

Gli operatori logici consentono di eseguire operazioni logiche su valori booleani. Ti consentono di combinare, negare o confrontare valori booleani e prendere decisioni logiche nel tuo codice in base al risultato.

Esplora i vari operatori logici supportati da JavaScript, incluso l'operatore di coalescenza Nullish ES6.

L'operatore logico AND (&&).

L'operatore AND (&&) è un operatore logico che restituisce VERO se entrambi gli operandi valutano a VERO E falso Altrimenti.

Ecco la sintassi dell'operatore AND:

un && b

Ecco un esempio dell'operatore AND in uso:

cost un = 5;
cost b = 10;
cost c = 15;
cost risultato_1 = (a < b) && (b < c);
consolare.log (risultato_1); // VERO
cost risultato_2 = (a > b) && (b < c);
consolare.log (risultato_2); // falso

In questo esempio, risultato_1 valuta a VERO perché i due operandi nell'espressione valutano a VERO. Tuttavia, risultato_2 valuta a falso perché il primo operando (un > b) ritorna falso.

instagram viewer

Se entrambi gli operandi non sono booleani, JavaScript tenterà di convertirli in valori booleani prima di valutare l'espressione. Per convertirli in booleani, JavaScript prima valuta se i valori sono veri o falsi.

JavaScript considera qualsiasi valore che non sia esplicitamente falso, un valore veritiero. Quando vengono convertiti, valutano un valore booleano VERO.

Tuttavia, alcuni valori e tipi di dati in JavaScript sono falsi, quindi quando JavaScript li converte, restituiscono un valore booleano falso.

I valori falsi in JavaScript sono:

  • falso
  • nullo
  • non definito
  • NaN (Non un numero)
  • 0
  • BigInt (0 n)
  • Stringa vuota ("" O '' O ``)
  • non definito

Quando si utilizza l'operatore AND per valutare valori non booleani, l'espressione restituisce immediatamente il valore del primo operando se l'operando è falso senza valutare il secondo. Questo comportamento è noto come cortocircuito e puoi usarlo per scrivere istruzioni condizionali in JavaScript.

Tuttavia, se il primo operando è vero, l'espressione procede a valutare il secondo operando. Se il secondo operando è vero, lo restituisce.

Per esempio:

cost un = 5;
cost b = 'Ciao';
cost c = nullo;
cost risultato_1 = a && b;
consolare.log (risultato_1); // "Ciao"
cost risultato_2 = c && b;
consolare.log (risultato_2); // nullo

In questo esempio, risultato_1 restituisce "Ciao" perché entrambi gli operandi nell'espressione sono veritieri. Tuttavia, risultato_2 cortocircuiti e ritorni nullo senza valutare il secondo operando.

Si noti che se sono presenti più operandi, l'operatore AND continuerà a valutarli finché non incontra un valore falso. Se non incontra un valore falso restituisce l'ultimo valore vero che incontra.

L'operatore logico OR (||).

L'operatore OR (||) è un operatore logico che restituisce VERO se e solo se uno o più dei suoi operandi lo sono VERO. Ritorna solo falso quando entrambi gli operandi sono falso.

Ecco la sintassi dell'operatore OR:

un || B

Ecco un esempio dell'operatore OR in uso:

cost un = 5;
cost b = 10;
cost c = 15;
cost risultato_1 = (a < b) || (bconsolare.log (risultato_1); // VERO


cost risultato_2 = (a > b) || (bconsolare.log (risultato_2); // VERO
cost risultato_3 = (a > b) || (b > c);
consolare.log (risultato_3); // falso

Nell'esempio sopra, risultato_1 valuta a VERO perché entrambi gli operandi nell'espressione valutano a VERO. risultato_2 valuta a VERO perché il secondo operando valuta a VERO. risultato_3 valuta a falso perché i due operandi nell'espressione valutano a falso.

Quando utilizzi l'operatore OR in contesti non booleani, JavaScript tenta di convertire in valori booleani prima di valutare l'espressione.

Quando l'espressione viene valutata, se il primo operando è vero, l'operatore lo cortocircuita e lo restituisce. Tuttavia, se è falso, procede a valutare l'operando successivo finché non incontra un operando veritiero. Se non ci sono operandi veri nell'espressione, restituisce l'ultimo valore falso che incontra.

Per esempio:

cost un = 5;
cost b = 'Ciao';
cost c = nullo;
cost risultato_1 = a || B;
consolare.log (risultato_1); // 5


cost risultato_2 = c || B;
consolare.log (risultato_2); // "Ciao"
cost risultato_3 = c || " ";
consolare.log (risultato_3); // " "

Nell'esempio sopra, risultato_1 cortocircuiti e ritorni 5 perché è un valore veritiero. risultato_2 restituisce “Ciao” ​​perché è il primo valore di verità che incontra nell'espressione. risultato_3 restituisce una stringa vuota perché è l'ultimo valore falso nell'espressione.

L'operatore logico NOT (!).

L'operatore logico NOT (!) è un operatore unario che restituisce il valore booleano opposto del suo operando.

Ecco la sintassi dell'operatore NOT:

!X

Dove X è un valore booleano o vero o falso.

Ecco un esempio dell'operatore NOT in uso:

cost un = 5;
cost b = '';
cost c = VERO;
cost risultato_1 = !a;
consolare.log (risultato_1); // falso


cost risultato_2 = !b;
consolare.log (risultato_2); // VERO
cost risultato_3 = !c;
consolare.log (risultato_3); // falso

Nell'esempio precedente, l'operatore NOT restituisce il valore inverso degli operandi booleani. Quando si utilizza l'operatore NOT in contesti non booleani (risultato_1 & risultato_2), converte i valori veri nel valore inverso di VERO e converte i valori falsi nel valore inverso di falso.

L'operatore Nullish Coalescing (??).

L'operatore di coalescenza nullo è un operatore logico che valuta due operandi e restituisce il primo operando se non lo è nullo O non definito. In caso contrario, restituisce il secondo operando.

A prima vista, l'operatore nullish coalescing potrebbe sembrare identico all'operatore OR logico (||), ma non è così. La differenza fondamentale è che l'operatore OR restituisce l'operando di destra se l'operando di sinistra è "qualsiasi" valore falso, non solo nullo O non definito.

Fornisce un modo conciso di scegliere un valore predefinito durante l'incontro nullo O non definito valori.

Ecco la sintassi per l'operatore di coalescenza nullo:

X?? si

Ecco un esempio dell'operatore di coalescenza nullo in uso:

cost nome = nullo;
cost defaultName = "Giovanni Rossi";
cost risultato_1 = nome?? predefinitoNome;
consolare.log (risultato_1); // "John Doe"


cost età = 0;
cost defaultEtà = 25;
cost result_2 = età?? defaultEtà;
consolare.log (risultato_2); // 0

Nell'esempio sopra, risultato_1 restituisce "John Doe" perché il primo operando aveva un valore di nullo. risultato_2 ritorna 0 perché, sebbene sia un valore falso, non lo è né l'uno né l'altro nullo né non definito.

Utilizzo degli operatori logici nel codice

Gli operatori logici sono comunemente usati per scrivere istruzioni condizionali, assegnare valori predefiniti o alternare valori booleani in base alle condizioni.

Utilizzando questi operatori logici, puoi scrivere codice più conciso ed espressivo che gestisce diversi scenari basati sulla veridicità o falsità dei valori.