In JavaScript ci sono quattro operatori logici: || (OR), && (AND), e ! (NOT), ?? (Nullish Coalescing). Qui abbiamo trattato i primi tre, l’operatore ?? sarà approfondito nel prossimo articolo.

Nonostante si chiamino “logici”, possono essere applicati a valori di qualsiasi tipo, non solo ai booleani (i risultati stessi possono essere di qualunque tipo).

Vediamoli nei dettagli.

|| (OR)

L’operatore “OR” viene rappresentato da due linee verticali:

result = a || b;

Nella programmazione classica, l’OR logico è utilizzato per manipolare solo tipi booleani. Se almeno un argomento è true, allora il risultato sarà true, altrimenti sarà false.

In JavaScript questo operatore è un po’ più potente. Ma prima vediamo come si comporta con i valori booleani.

Ci sono quattro combinazioni logiche possibili:

alert( true || true );   // true
alert( false || true );  // true
alert( true || false );  // true
alert( false || false ); // false

Come possiamo vedere, il risultato è sempre true, tranne nei casi in cui entrambi gli operandi sono false.

Se un operando non è di tipo booleano, allora viene momentaneamente convertito per la valutazione.

Ad esempio, il numero 1 viene considerato come true, il numero 0 come false:

if (1 || 0) { // funziona proprio come ( true || false )
  alert( 'truthy!' );
}

La maggior parte delle volte, OR || viene utilizzato in un if per verificare se almeno una delle condizioni è vera.

Ad esempio:

let hour = 9;

if (hour < 10 || hour > 18) {
  alert( 'The office is closed.' );
}

Possiamo passare molteplici condizioni:

let hour = 12;
let isWeekend = true;

if (hour < 10 || hour > 18 || isWeekend) {
  alert( 'The office is closed.' ); // l'Ufficio è chiuso
}

OR "||" trova il primo valore vero

La logica descritta sopra è ovvia. Adesso proviamo ad addentrarci in qualche caratteristica “extra” di JavaScript.

Si può estendere l’algoritmo come segue.

Dati svariati operandi:

result = value1 || value2 || value3;

L’operatore OR || si comporta come segue:

• Valuta gli operandi da sinistra a destra.
• Ogni operando viene convertito a booleano. Se il risultato è true, il logical OR si ferma e ritorna il valore originale dell’operando.
• Se tutti gli operandi sono stati valutati e nessuno è true, ritorna l’ultimo operando.

Un valore viene ritornato nella sua forma originale, non nella sua conversione booleana.

In altre parole, una catena di OR "||" ritorna il primo valore vero; se invece non ce ne sono ritorna l’ultimo valore.

Ad esempio:

alert( 1 || 0 ); // 1 (1 è vero)

alert( null || 1 ); // 1 (1 è il primo valore true)
alert( null || 0 || 1 ); // 1 (il primo valore true)

alert( undefined || null || 0 ); // 0 (tutti falsi, ritorna l'ultimo valore)

Questo ci permette alcuni utilizzi interessanti rispetto al “puro e classico OR booleano"boolean-only OR”.

1. Trovare il primo valore vero in una lista di variabili o espressioni.

   Immaginiamo di avere diverse variabili, firstName, lastName e nickName, tutte opzionali (possono quindi essere undefined o avere valori falsi).

   Possiamo utilizzare OR || per selezionare quella che contiene un valore e mostrarlo (oppure mostrare "Anonymous" se nessuna variabile è definita):

   let firstName = "";
   let lastName = "";
   let nickName = "SuperCoder";
   
   alert( firstName || lastName || nickName || "Anonymous"); // SuperCoder

   Se tutte le variabili sono false, verrà mostrato "Anonymous".

2. Valutazione a Corto-Circuito.

   Gli operandi, oltre che valori, possono essere anche espressioni arbitrarie. L’operatore OR esegue la valutazione da sinistra a destra e si ferma al primo risultato vero, il quale viene ritornato. Il processo è chiamato “valutazione a corto-circuito” perché cerca di concludersi il prima possibile, senza dover elaborare tutti gli operandi.

<<<<<<< HEAD Il logical OR è particolarmente utile quando il secondo argomento causerebbe un side-effect come l’assegnazione di una variabile o la chiamata a una funzione. Nell’esempio che segue solo il secondo messaggio verrà mostrato.

It means that `||` processes its arguments until the first truthy value is reached, and then the value is returned immediately, without even touching the other argument.

The importance of this feature becomes obvious if an operand isn't just a value, but an expression with a side effect, such as a variable assignment or a function call.

In the example below, only the second message is printed:

8d04d0d2db97276dbb2b451c30a7bd3e05d65831

```js run no-beautify
*!*true*/!* || alert("not printed");
*!*false*/!* || alert("printed");
```

Nella prima linea l’operatore OR trova subito un valore vero e ferma immediatamente la valutazione, quindi alert non viene eseguito. Si può utilizzare questa funzionalità per eseguire un commando nel caso in cui la prima parte della condizione sia falsa.

&& (AND)

L’operatore AND viene rappresentato con &&:

result = a && b;

Nella programmazione classica AND ritorna true se entrambi gli operandi sono veri, altrimenti ritorna false:

alert( true && true );   // true
alert( false && true );  // false
alert( true && false );  // false
alert( false && false ); // false

Un esempio con if:

let hour = 12;
let minute = 30;

if (hour == 12 && minute == 30) {
  alert( 'The time is 12:30' );
}

Proprio come per OR, anche per AND è consentito qualsiasi valore come operando:

if (1 && 0) { // valutato come true && false
  alert( "won't work, because the result is falsy" );
}

AND “&&” trova il primo valore falso

Dati svariati operandi:

result = value1 && value2 && value3;

L’operatore AND && si comporta come segue:

• Valuta gli operandi da sinistra a destra.
• Ogni operando viene convertito a booleano. Se il risultato è false, si ferma e ritorna il valore originale dell’operando.
• Se tutti gli operandi precedenti sono stati valutati e nessuno è false, ritorna l’ultimo operando.

In altre parole, AND ritorna il primo valore falso, altrimenti ritorna l’ultimo valore.

Le regole sono molto simili a quelle dell’OR. La differenza è che AND ritorna il primo valore falso mentre OR ritorna il primo valore vero.

Esempi:

// se il primo operando è vero,
// AND ritorna il secondo operando:
alert( 1 && 0 ); // 0
alert( 1 && 5 ); // 5

// se il primo operando è falso
// AND lo ritorna. Il secondo operando viene ignorato
alert( null && 5 ); // null
alert( 0 && "no matter what" ); // 0

Possiamo anche passare diversi valori in una sola riga. Nota come il primo valore falso viene ritornato non appena raggiunto:

alert( 1 && 2 && null && 3 ); // null

Quando tutti i valori sono veri, viene ritornato l’ultimo valore:

alert( 1 && 2 && 3 ); // 3, l'ultimo

let x = 1;

(x > 0) && alert( 'Greater than zero!' );

let x = 1;

if (x > 0) alert( 'Greater than zero!' );

! (NOT)

L’operatore booleano NOT viene rappresentato dal punto esclamativo !.

La sintassi è piuttosto semplice:

result = !value;

L’operatore accetta un solo argomento e si comporta come segue:

1. Converte l’operando a booleano: true/false.
2. Ritorna il valore inverso.

Ad esempio:

alert( !true ); // false
alert( !0 ); // true

Un doppio NOT !! viene talvolta utilizzato per convertire un valore al tipo booleano:

alert( !!"non-empty string" ); // true
alert( !!null ); // false

Quello che accade è che il primo NOT converte l’operando a booleano e ritorna il suo inverso, e il secondo NOT lo inverte nuovamente. Il risultato è un valore di tipo booleano.

C’è un modo molto più lungo per fare la stessa cosa, usare la funzione Boolean, integrata in JavaScript:

alert( Boolean("non-empty string") ); // true
alert( Boolean(null) ); // false

La precedenza del NOT ! è la più alta fra tutti gli operatori logici; viene sempre eseguita per prima e precede sia && che ||.