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.

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