Variabili non definite, valore == false contro valore!

Question

Ho un problema con un codice molto semplice scritto in Javascript, potresti aiutarmi per favore?

Ecco cosa penso di avere a capire finora su JavaScript e le variabili:

• un valore indefinito viene valutata false in un'operazione booleana
• Utilizzando un operatore == in una comparazione, si' chiedendo se due valori sono confrontabili indipendentemente dai loro tipi

Ho trovato un file di esercitazione in un corso online e ho provato a farlo, ma non ho ottenuto lo stesso risultato previsto nella lezione; il problema principale era che stavo confrontando il valore con un "if value == false {...}" mentre la soluzione utilizzava "if! value {...}"

Quindi ho deciso di scrivere un codice molto breve per provarlo da solo, ma sto ottenendo risultati misti. Qui nell'esempio seguente mi aspetto che questo codice JS generi due avvisi identici ("foo è uguale a false"), ma invece la prima istruzione if restituisce "foo NON è uguale a false" mentre il secondo se restituisce (come previsto) "foo è uguale a false".

questo è ciò che scritto:

var foo = undefined; 

if (foo == false) { 
    alert("foo is equal to false"); 
} else { 
    alert("foo is not equal to false"); // Javascript executes this row 
} 

if (!foo) { 
    alert("foo is equal to false"); // Javascript executes this row 
} else { 
    alert("foo is not equal to false"); 
} 

AFAIK i due FI dovrebbe fare lo stesso lavoro, e infatti quando ho provato sostituendo nella prima riga il valore "var foo = indefinito;" con "var foo = 0;" ha funzionato come previsto, e 0 è un altro valore che dovrebbe essere valutato come falso, o almeno questo è ciò che ricordo.

Potresti dirmi cosa sto facendo male?

Answer 1

Il == algoritmo (Abstract Equality Comparison Algorithm) non è qualcosa in cui puoi semplicemente assumere un risultato a meno che tu non conosca l'algoritmo. Devi conoscere i dettagli di come funziona.

Ad esempio, null e undefined sono un caso speciale. Non fanno alcuna conversione di tipo se non quella di essere considerati uguali tra loro.

Altrimenti c'è tipicamente una conversione di tipo che tenta di ridurre entrambi gli operandi a un tipo comune. Questo spesso finisce per essere una conversione da a.

Ecco perché:

• null == undefined; // true

• null == 0; // false

• +null == '0' // true

Quindi, se si sa come funziona l'algoritmo, si sa che undefined non equivale mai a nulla tranne undefined e null, ma altri tipi non strettamente uguali possono essere forzati a tipi uguali.

Così facendo if(!x) vs if(x==false) sono test completamente diversi.

• if(!x) esegue toBoolean conversione.

• if(x == false) utilizza un algoritmo complesso per decidere la conversione corretta.

Quindi, con ...

if(x == false) 

... se x è undefined, è determinato a non essere uguale a false, ma se x è 0 o addirittura "0", esso sarà considerato uguale a false.

• 0 == false; // true

• "0" == false; // true

Answer 2

indefinito non è uguale a false, ma quando si sta cercando di evaulate:

if (undefined) 

l'intera espressione è sempre false

maggiori informazioni: http://www.mapbender.org/JavaScript_pitfalls:_null,_false,_undefined,_NaN

Answer 3

Verità e l'equivalenza con true sono due cose diverse in JavaScript.

Il if (...) esegue la prima istruzione se la ... è "truthy", non quando sono "uguali" a qualsiasi altro particolare valore, in modo che il secondo condizionale dovrebbe essere simile

if (!foo) { 
    alert("foo is falsy"); // Javascript executes this row 
} else { 
    alert("foo is truthy"); 
} 

Ci sono abbastanza alcuni valori "falsy" in JavaScript: NaN, "", 0, -0, false, null, undefined. Tutti gli altri valori sono truthy.

L'operatore ! restituisce false per qualsiasi valore truthy e true per qualsiasi valore falsy, così !x è lo stesso per tutti (x ? false : true)x.

Answer 4

Come regola generale trovo che il risultato positivo è più facile da analizzare, quasi come se if(!foo) è un doppio negativo, quindi mi piacerebbe tendono a girare intorno:

if (foo) { 
    alert("foo is something or boolean true"); 
} else { 
    alert("foo is null, undefined or boolean false"); 
} 

In particolare sia undefined e null non sono veri o falsi, ma javascript può gestire una sorta di abbreviazione perché è dinamico.

Davvero la dichiarazione di cui sopra è qualcosa di simile:

if (foo != null && (foo.constructor !== Boolean || foo == true)) { 
    alert("foo is something or boolean true"); 
} else { 
    alert("foo is null, undefined or boolean false"); 
} 

si sta controllando prima che è stata definita la variabile e poi che se è booleano che è vero.

Nel frattempo la sua dichiarazione falsa sta controllando qualcosa di diverso:

if (foo == false) { 
    alert("foo is populated with the boolean false"); 
} else { 
    alert("foo is true, something else or null"); 
}