In JavaScript, perché "0" è uguale a falso, ma quando testato da "if" non è falso da solo?

Quanto segue mostra che "0"è falso in Javascript:

>>> "0" == false
true

>>> false == "0"
true

Quindi perché stampa quanto segue "ha"?

>>> if ("0") console.log("ha")
ha

Il motivo è che quando lo fai esplicitamente "0" == false, entrambi i lati vengono convertiti in numeri e quindi viene eseguito il confronto.

Quando lo fai if ("0") console.log("ha"):, il valore della stringa è in fase di test. Qualsiasi stringa non vuota lo è true, mentre una stringa vuota lo è false.

Uguale (==)

Se i due operandi non sono dello stesso tipo , JavaScript converte gli operandi quindi applica un confronto rigoroso. Se uno degli operandi è un numero o un valore booleano , gli operandi vengono convertiti in numeri se possibile; altrimenti se uno degli operandi è una stringa , l'altro operando viene convertito in una stringa se possibile. Se entrambi gli operandi sono oggetti , JavaScript confronta i riferimenti interni uguali quando gli operandi si riferiscono allo stesso oggetto in memoria.

(Da operatori di confronto nella rete di sviluppatori Mozilla)

Tabelle che mostrano il problema:

e ==

Morale della storia usa ===

credito di generazione della tabella: https://github.com/dorey/JavaScript-Equality-Table

È secondo le specifiche.

12.5 L'istruzione if 
.....

2. Se ToBoolean (GetValue (exprRef)) è true, allora 
un. Restituisce il risultato della valutazione della prima istruzione.
3. Altrimenti, 
....

ToBoolean, secondo le specifiche, è

L'operazione astratta ToBoolean converte il suo argomento in un valore di tipo Booleano secondo la Tabella 11:

E quella tabella dice questo sulle stringhe:

Il risultato è falso se l'argomento è la stringa vuota (la sua lunghezza è zero); altrimenti il ​​risultato è vero

Ora, per spiegare perché "0" == falsedovresti leggere l'operatore di uguaglianza, che afferma che ottiene il suo valore dall'operazione astratta GetValue(lref)corrisponde allo stesso per il lato destro.

Che descrive questa parte rilevante come:

se IsPropertyReference (V), quindi 
un. Se HasPrimitiveBase (V) è falso, allora lascia che sia il metodo interno [[Get]] di base, altrimenti lascia che get
essere lo speciale metodo interno [[Get]] definito di seguito. 
b. Restituisce il risultato della chiamata del metodo get interno utilizzando base come suo valore e passaggio
GetReferencedName (V) per l'argomento

O in altre parole, una stringa ha una base primitiva, che richiama il metodo get interno e finisce per sembrare falsa.

Se si desidera valutare le cose utilizzando l'operazione GetValue, utilizzare ==se si desidera valutare utilizzando ToBoolean, ===(noto anche come operatore di parità "rigoroso")

È PHP in cui la stringa "0"è falsy (false-when-used-in-boolean-context). In JavaScript, tutte le stringhe non vuote sono veritiere.

Il trucco è che ==nei confronti di un booleano non viene valutato in un contesto booleano, viene convertito in numero e nel caso di stringhe eseguite analizzando come decimale. Quindi ottieni Number 0invece della verità booleana true.

Questo è un po 'povero di design del linguaggio ed è uno dei motivi per cui cerchiamo di non usare lo sfortunato ==operatore. Usa ===invece.

// I usually do this:

x = "0" ;

if (!!+x) console.log('I am true');
else      console.log('I am false');

// Essentially converting string to integer and then boolean.

Le virgolette intorno alla 0rendono una stringa, che viene valutata come vera.

Rimuovi le virgolette e dovrebbe funzionare.

if (0) console.log("ha") 

È tutto a causa delle specifiche ECMA ... a "0" == falsecausa delle regole specificate qui http://ecma262-5.com/ELS5_HTML.htm#Section_11.9.3 ... E if ('0')restituisce true a causa delle regole specificate qui http: / /ecma262-5.com/ELS5_HTML.htm#Section_12.5

L'espressione "if" verifica la veridicità, mentre il doppio eguaglia test per l'equivalenza indipendente dal tipo. Una stringa è sempre vera, come altri hanno sottolineato qui. Se il doppio uguale testasse la veridicità di entrambi i suoi operandi e quindi confrontasse i risultati, otterresti il ​​risultato che stavi assumendo intuitivamente, cioè ("0" == true) === true. Come dice Doug Crockford nel suo eccellente JavaScript: le parti buone ", le regole secondo cui [== costringe i tipi dei suoi operandi] sono complicate e non memorabili .... La mancanza di transitività è allarmante". Basti dire che uno degli operandi è forzato per corrispondere all'altro e che "0" finisce per essere interpretato come zero numerico,

== L' operatore di uguaglianza valuta gli argomenti dopo averli convertiti in numeri. Quindi la stringa zero "0" viene convertita in tipo di dati Numero e il valore booleano falso viene convertito in Numero 0. Quindi

"0" == false // true

Lo stesso vale per `

false == "0" //true

=== Il rigoroso controllo dell'uguaglianza valuta gli argomenti con il tipo di dati originale

"0" === false // false, because "0" is a string and false is boolean

Lo stesso vale per

false === "0" // false

Nel

if("0") console.log("ha");

La stringa "0" non viene confrontata con nessun argomento e la stringa è un valore vero fino a quando o se non viene confrontata con alcun argomento. È esattamente come

if(true) console.log("ha");

Ma

if (0) console.log("ha"); // empty console line, because 0 is false

`

Questo perché JavaScript utilizza la coercizione dei tipi nei contesti booleani e nel codice

if ("0") 

sarà costretto a diventare vero in contesti booleani.

Ci sono altri valori di verità in Javascript che saranno costretti a veri in contesti booleani e quindi eseguiranno i blocchi if: -

if (true)
if ({})
if ([])
if (42)
if ("0")
if ("false")
if (new Date())
if (-42)
if (12n)
if (3.14)
if (-3.14)
if (Infinity)
if (-Infinity)

if (x) 

coercisce x utilizzando JavaScript toBoolean interno (http://es5.github.com/#x9.2)

x == false

costringe entrambe le parti a utilizzare la coercizione interna toNumber (http://es5.github.com/#x9.3) o ToPrimitive per gli oggetti (http://es5.github.com/#x9.1)

Per i dettagli completi consultare http://javascriptweblog.wordpress.com/2011/02/07/truth-equality-and-javascript/