Operatori logici

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.

   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.

   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 ||.