Operatori di confronto

Gli operatori di confronto confrontano i valori di due operandi e valutano se l'affermazione che formano è true o false. L'esempio seguente utilizza l'operatore di uguaglianza rigorosa (===) per confrontare due operandi: l'espressione 2 + 2 e il valore 4. Poiché il risultato dell'espressione e il valore numerico 4 sono uguali, questa espressione restituisce true:

2 + 2 === 4
> true

Coercizione e uguaglianza di tipo

Due degli operatori di confronto più utilizzati sono == per l'uguaglianza approssimativa e === per l'uguaglianza rigorosa. == esegue un confronto approssimativo tra due valori forzando gli operandi a tipi di dati corrispondenti, se possibile. Ad esempio, 2 == "2" restituisce true, anche se il confronto viene eseguito tra un valore numerico e un valore stringa.

2 == 2
> true

2 == "2"
> true

Lo stesso vale per !=, che restituisce true solo se gli operandi confrontati non sono approssimativamente uguali.

2 != 3
> true

2 != "2"
> false

I confronti rigorosi che utilizzano === o !== non eseguono la coercizione di tipo. Affinché un confronto rigoroso restituisca il valore true, i valori confrontati devono avere lo stesso tipo di dati. Per questo motivo, 2 == "2" restituisce true, ma 2 === "2" restituisce false:

2 === 3
> false

2 === "2"
> false

Per rimuovere qualsiasi ambiguità che potrebbe derivare dalla coercizione automatica, utilizza === se possibile.

Operatore	Descrizione	Utilizzo	Risultato
===	Esattamente uguale	2 === 2	true
!==	Non strettamente uguale	2 !== "2"	true
==	Uguale (o "approssimativamente uguale")	2 == "2"	true
!=	Non uguale	2 != "3"	true
>	Maggiore di	3 > 2	true
>=	Maggiore o uguale a	2 >= 2	true
<	Minore di	2 < 3	true
<=	Minore o uguale a	2 <= 3	true

Valori veri e falsi

Tutti i valori in JavaScript sono implicitamente true o false e possono essere forzati al valore booleano corrispondente, ad esempio utilizzando il comparatore "approssimativamente uguale". Un insieme limitato di valori viene forzato su false:

• 0
• null
• undefined
• NaN
• Una stringa vuota ("")

Tutti gli altri valori vengono forzati a true, incluse le stringhe contenenti uno o più caratteri e tutti i numeri diversi da zero. Questi valori sono comunemente chiamati valori "veri" e "falsi".

"My string" == true
> true

100 == true
> true

0 == true
> false

Operatori logici

Utilizza gli operatori AND (&&), OR (||) e NOT (!) logici per controllare il flusso di uno script in base alla valutazione di due o più istruzioni condizionali:

2 === 3 || 5 === 5;
> true

2 === 2 && 2 === "2"
> false

2 === 2 && !"My string."
> false

Un'espressione logica NOT (!) nega il valore vero o falso di un operando, restituendo true se l'operando restituisce false e false se l'operando restituisce true:

true
> true

!true
> false

!false
> true

L'utilizzo dell'operatore logico NON (!) davanti a un altro tipo di dati, ad esempio un numero o una stringa, forza il valore in un booleano e inverte il valore vero o falso del risultato.

"string"
> "string"

!"string"
> false

0
> 0

!0
> true

È prassi comune utilizzare due operatori NOT per forzare rapidamente i dati al valore booleano corrispondente:

!!"string"
> true

!!0
> false

Gli operatori AND e OR logici non eseguono alcuna coercizione da soli. Rimontano il valore di uno dei due operandi in fase di valutazione, con l'operando scelto determinato da questa valutazione.

L'operatore AND logico (&&) restituisce il primo dei due operandi solo se questo viene valutato come false e, in caso contrario, il secondo operando. Nei confronti che si valutano in valori booleani, restituisce true solo se gli operandi su entrambi i lati dell'operatore AND logico si valutano in true. Se uno dei lati restituisce false, viene visualizzato false.

true && false
> false

false && true
> false

false && false
> false

true && true
> true

Quando && viene utilizzato con due operandi non booleani, il primo operando viene restituito immutato se può essere forzato in false. Se il primo operando può essere forzato in true, il secondo operando viene restituito invariato:

false && "My string"
> false

null && "My string"
> null

"My string" && false
> false

"My string" && "My second string"
> "My second string"

2 === 2 && "My string"
> "My string"

L'operatore OR logico (||) restituisce il primo dei due operandi solo se questo viene valutato come true e, in caso contrario, il secondo operando. Nei confronti che risultano in valori booleani, significa che restituisce true se uno degli operandi risulta in true e, se nessuno dei due operandi risulta in true, restituisce false:

true || false
> true

false || true
> true

true || true
> true

false || false
> false

Quando viene utilizzato || con due operandi non booleani, viene restituito il primo operando immutato se può essere forzato in true. Se il primo operando può essere forzato in false, il secondo operando viene restituito invariato:

false || "My string"
> "My string"

null || "My string"
> "My string"

"My string" || false
> "My string"

"My string" || "My second string"
> "My string"

2 === 2 || "My string"
> true

Operatore di unione di valori null

Introdotto in ES2020, l'"operatore di unione nullo" (??) restituisce il primo operando solo se questo operando ha un valore diverso da null o undefined. In caso contrario, restituisce il secondo operando.

null ?? "My string"
> "My string"

undefined ?? "My string"
> "My string"

true ?? "My string";
> true

?? è simile a un OR logico, ma più rigoroso nel modo in cui viene valutato il primo operando. || restituisce il secondo operando per qualsiasi espressione che può essere coercita in false, inclusi undefined e null. ?? restituisce il secondo operando solo quando il primo è strettamente uguale a null o undefined, anche se potrebbe essere forzato a false:

0 ?? "My string";
> 0

false ?? "My string";
> false

undefined ?? "My string";
> "My string"

Operatori di assegnazione logica

Utilizza gli operatori di assegnazione per assegnare il valore di un secondo operatore a un primo operatore. L'esempio più comune è un singolo segno di uguale (=), utilizzato per assegnare un valore a una variabile dichiarata.

Utilizza gli operatori di assegnazione logica per assegnare in modo condizionale un valore a una variabile in base al valore vero o falso della variabile.

L'operatore di assegnazione AND logico (&&=) valuta il secondo operando e lo assegna al primo solo se il primo operando ha valore true. In pratica, "se il primo operando è vero, assegnagli il valore del secondo operando".

let myVariable = false;
myVariable &&= 2 + 2;
> false

myVariable = true;
myVariable &&= 2 + 2;
> 4

Il valore vero o falso del primo operando determina se viene eseguita un'assegnazione. Tuttavia, il tentativo di valutare il primo operando utilizzando un operatore di confronto genera un valore booleano true o false, a cui non è possibile assegnare un valore:

let myVariable = 5;
myVariable > 2 &&= "My string"
> SyntaxError: Invalid left-hand side in assignment

L'operatore di assegnazione OR logico (||=) valuta il secondo operando e lo assegna al primo se il primo operando ha valore false, ovvero "se il primo operando è falso, assegnagli il valore del secondo operando".

let myVariable = false;
myVariable ||= 2 + 2;
> 4

myVariable = true;
myVariable ||= 2 + 2;
> true

Verificare di aver compreso

Quale operatore indica "rigorosamente uguale"?

===

==

=

!=