Come funziona il confronto (A == B == C) in JavaScript?

Question

mi aspettavo il seguente confronto per dare un errore:

var A = B = 0; 
if(A == B == 0) 
    console.log(true); 
else 
    console.log(false); 

ma stranamente restituisce false.

Ancora più stranamente,

console.log((A == B == 1)); 

rendimenti true.

Come funziona questo tipo di confronto "ternario"?

Answer 1

In primo luogo, abbiamo bisogno di capire che un confronto == tra un numero e un valore booleano si tradurrà in conversione di tipo interno del valore booleano ad un numero (true diventa 1 e false diventa 0)

L'espressione che avete dimostrato viene valutata da sinistra a destra. Quindi, prima

A == B 

viene valutata e il risultato è true e si confrontano true con 0. Dal true diventa 1 durante il confronto, 1 == 0 viene valutato come false. Ma quando si dice

console.log((A == B == 1)); 

A == B è true, che se confrontato con il numero, diventa 1 e si sta confrontando con 1 che ancora una volta. Questo è il motivo per cui stampa true.

Answer 2

if((A == B)&& (A== 0)&& (B==0)) 
    console.log(true); 
else 
    console.log(false); 

Answer 3

In primo luogo, A == B rendimenti true, che viene quindi confrontato con 0, true == 0 che restituisce falso, o true == 1 che restituisce vero.

Answer 4

Prima controlla la clausola per A == B, che è true, che inizia a verificare true == 0, e 0 è falso. Quindi quando controlli A == B == 1, controlli A == B, che è true, e true == 1. Quindi restituisce true. Se davvero si vuole controllare tutte le possibilità che si dovrebbe fare qualcosa di simile:

if((A==B) && (A==0)) 
    console.log(true); 
else 
    console.log(false); 

Answer 5

È possibile lavorare da sinistra a destra. In questo caso, per prima cosa controlla se A == B, quindi controlli se questo è uguale a 0. Quindi, poiché A == B, è vero. Così ora diventa (true == 0), che è falso. Se A = 1, B = 2, quindi (A == B == 0) restituirebbe true! Questo perché A == B è falso e (false == 0) è vero!

Answer 6

Operatori di assegnazione come = sono destra-associativo: quando v'è una serie di questi operatori che hanno la stessa priorità, vengono elaborati da destra a sinistra, così A = B = 0 viene elaborato come A = (B = 0) (B = 0 restituisce 0, così sia A che B finiscono come 0).

Operatori di uguaglianza come == sono associativo a sinistra: gli operatori con precedenza identica vengono elaborati da sinistra a destra. A == B == 0 viene elaborato come (A == B) == 0 e poiché A == B è true (1), diventa 1 == 0, che è falso (0).

Allo stesso modo, A == B == 1 viene elaborato come (A == B) == 1, che diventa 1 == 1, che è true (1).

Fonte e ulteriori informazioni: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence