In Javascript, <int-value> == "<int-value>" è true. Perché è così?

Question

Se faccio 0 == "0", viene valutato true. Prova,

if(-777 == "-777") alert("same"); 

avviso si verifica.

E, è anche evidente che true == "true" non è true. Prova,

if(false == "false") alert("same"); 

avviso non succede.

Perché è così?

Answer 1

Il comportamento di == è un po 'lunga, ma chiaramente definito nella ecma-262 spec:

11.9.3 Abstract uguaglianza Confronto Algoritmo

Il confronto x == y, dove xey sono valori, produce vero o falso. Tale confronto viene eseguita come segue :

1. Se Type (x) è diverso dal tipo (y), passare al punto 14.
2. Se Type (x) è indefinito, ritorno vero.
3. Se Type (x) è Null, restituisce true.
4. Se Type (x) non è Number, andare al passaggio 11.
5. Se x è NaN, restituire false.
6. Se y è NaN, restituisce falso.
7. Se x è lo stesso valore numerico di y, restituisce true.
8. Se x è +0 e y è -0, restituisce true.
9. Se x è -0 e y è +0, restituisce true.
10. Ritorno falso.
11. Se Type (x) è String, restituisce true se xey sono esattamente la stessa sequenza di caratteri (stessa lunghezza e gli stessi caratteri nelle corrispondenti posizioni ). Altrimenti, restituisci falso.
12. Se Type (x) è booleano, restituisce true se xey sono entrambi veri o entrambi false. Altrimenti, restituisci falso.
13. Restituisce vero se xey si riferiscono allo stesso oggetto o se si riferiscono a oggetti uniti tra loro (vedere 13.1.2). Altrimenti, restituisci falso.
14. Se x è nullo e y non è definito, restituisce true.
15. Se x non è definito e y è nullo, restituisce true.
16. Se Type (x) è Number e Type (y) è String, restituisce il risultato del confronto x == ToNumber (y).
17. Se Type (x) è String e Type (y) è Number, restituisce il risultato del confronto ToNumber (x) == y.
18. Se Type (x) è booleano, restituisce il risultato del confronto ToNumber (x) == y.
19. Se Type (y) è booleano, restituisce il risultato del confronto x == ToNumber (y).
20. Se Type (x) è o String o Number e Type (y) è Object, restituisce il risultato del confronto x == ToPrimitive (y).
21. Se Type (x) è Object e Type (y) è String o Number, restituire il risultato del confronto ToPrimitive (x) == y.
22. Ritorno falso.

Passo 16 si applica al vostro precedente esempio:

0 == "0"   // apply 16 
≡ 0 == toNumber("0") 
≡ 0 == 0    // apply 7 
≡ true 

E passo 18, poi passo 16, si applicano a questi ultimi:

true == "true"   // apply 18 
≡ toNumber(true) == "true" 
≡ 1 == "true"    // apply 16 
≡ 1 == toNumber("true") 
≡ 1 == NaN     // apply 6 
≡ false 

Answer 2

Javascript non lancia "falso" in booleano falso, solo nella stringa "falso".

È possibile trasmettere liberamente valori di stringa al loro equivalente intero, quindi il primo esempio funziona.

Answer 3

Fare questo:

if(5 == "5") 

Rende javascript convertire i primi 5 in una stringa. Prova questo:

if(5 === "5") 

Il === rende JavaScript tipo valutare pure.

Questo è in realtà un duplicato di questo question dove viene spiegato molto bene.

Answer 4

Poiché Javascript è tipicamente digitato, trasmetterà automaticamente le variabili in base all'operazione e al tipo di altre variabili nell'operazione.

alert ("5" - 1); // 4 (int) 
alert ("5" + 1); // "51" (string) "+" is a string operator, too 
alert ("5" == 5); // true 

Cosa si potrebbe desiderare di guardare è identità controllo (===). Questo assicura che le variabili siano identiche, non solo uguale a.

alert("5" == 5); // true, these are equal 
alert("5" === 5); // false, these are not identical. 

vedere anche questa domanda: implementazione How do the equality and identity comparison operators differ? di PHP è molto simile a JavaScript di.

Answer 5

Javascript è un linguaggio con caratteri generici, quindi i tipi di esecuzione vengono eseguiti in fase di esecuzione ogni volta che l'interprete ritiene necessario. Se confronti un intero con una stringa, significa che dovrebbero essere dello stesso tipo, quindi, ad esempio, "34" == 34 è vero, poiché il numero intero verrebbe probabilmente convertito in una stringa prima del confronto.

La stringa "false" non è convertita in un valore booleano, mentre il valore bool false è convertito in una stringa, che avrebbe il valore "0", ovvero una stringa contenente il numero 0, che restituisce "0" "==" false ", che è ovviamente falso.

Se si desidera confrontare il valore senza fusione di caratteri automatica, confrontando in modo efficace i tipi così come i valori, utilizzare una tripla uguale:

5 === "5" false "stringa" === "stringa" vero

Answer 6

JavaScript ha due serie di operatori di uguaglianza:

• === and !== (severe operatori di uguaglianza)
• == and != (operatore di uguaglianza di serie s)

Gli operatori di uguaglianza standard, faranno il paragone giusto se entrambi gli operandi sono dello stesso tipo, ma è possibile ottenere alcuni risultati inaspettati se non sono dello stesso tipo, ad esempio:

'' == '0' // false 
0 == '' // true 
0 == '0' // true 
false == 'false' // false 
false == '0' // true 
false == undefined // false 
false == null // false 
null == undefined // true 
' \t\r\n ' == 0 // true 

Per questo consiglio sempre di usare gli operatori di uguaglianza rigorosa (===,! ==).

Answer 7

Perché è così?

Perché JavaScript è sia digitato in modo approssimativo che incoerente. Non tutte le sue caratteristiche di design sono ben pensate; è stato creato, implementato e implementato in modo incredibilmente veloce rispetto a qualsiasi altro linguaggio di programmazione, in una corsa a ottenere Netscape 2.0. Fu solo molto tempo dopo che si calmò, perse alcuni degli insetti più eclatanti e divenne semi-standardizzato.

Cercare un tipo di ragionamento filosofico per cose come le regole implicite del casting di tipo è probabilmente un esercizio infruttuoso. L'unico principio veramente coerente che JavaScript aderisce è DWIM, molto in senso negativo.

Answer 8

JavaScript definisce i valori di falsey come 0, booleano falso e non definito. Qualsiasi stringa esterna a "0" sarà vera, anche se quella stringa è "false".

Tipo di fastidioso, davvero.