En JavaScript, pourquoi «0» est-il égal à faux, mais lorsqu'il est testé par «si», il n'est pas faux en soi?

Ce qui suit "0"est faux en Javascript:

>>> "0" == false
true

>>> false == "0"
true

Alors, pourquoi le texte suivant s'imprime- "ha"t-il?

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

La raison en est que lorsque vous le faites explicitement "0" == false, les deux côtés sont convertis en nombres, puis la comparaison est effectuée.

Lorsque vous effectuez if ("0") console.log("ha"):, la valeur de chaîne est testée. Toute chaîne non vide l'est true, tandis qu'une chaîne vide l'est false.

Égal (==)

Si les deux opérandes ne sont pas du même type , JavaScript convertit les opérandes puis applique une comparaison stricte. Si l'un des opérandes est un nombre ou un booléen , les opérandes sont convertis en nombres si possible; sinon si l'un des opérandes est une chaîne , l'autre opérande est converti en chaîne si possible. Si les deux opérandes sont des objets , JavaScript compare les références internes qui sont égales lorsque les opérandes font référence au même objet en mémoire.

( Des opérateurs de comparaison dans Mozilla Developer Network)

Tableaux affichant le problème:

et ==

Morale de l'utilisation de l'histoire ===

crédit de génération de table: https://github.com/dorey/JavaScript-Equality-Table

C'est selon les spécifications.

12.5 L'instruction if 
.....

2. Si ToBoolean (GetValue (exprRef)) est vrai, alors 
une. Renvoie le résultat de l'évaluation de la première instruction.
3. Sinon, 
....

ToBoolean, selon la spécification, est

L'opération abstraite ToBoolean convertit son argument en une valeur de type Boolean selon le tableau 11:

Et ce tableau dit ceci à propos des chaînes:

Le résultat est faux si l'argument est la chaîne vide (sa longueur est nulle); sinon le résultat est vrai

Maintenant, pour expliquer pourquoi "0" == falsevous devriez lire l'opérateur d'égalité, qui indique qu'il obtient sa valeur de l'opération abstraite GetValue(lref)correspond de même pour le côté droit.

Qui décrit cette partie pertinente comme:

si IsPropertyReference (V), alors 
une. Si HasPrimitiveBase (V) est faux, alors get sera la méthode interne [[Get]] de base, sinon laissez get
être la méthode interne [[Get]] spéciale définie ci-dessous. 
b. Renvoie le résultat de l'appel de la méthode interne get en utilisant la base comme sa valeur this et en passant
GetReferencedName (V) pour l'argument

Ou en d'autres termes, une chaîne a une base primitive, qui rappelle la méthode interne get et finit par sembler fausse.

Si vous souhaitez évaluer des choses à l'aide de l'opération GetValue ==, si vous souhaitez évaluer à l'aide de ToBoolean, utilisez ===(également appelé opérateur d'égalité "strict")

C'est PHP où la chaîne "0"est fausse (false-when-used-in-boolean-context). En JavaScript, toutes les chaînes non vides sont véridiques.

L'astuce est que ==contre un booléen n'évalue pas dans un contexte booléen, il se convertit en nombre, et dans le cas des chaînes, cela se fait en analysant en décimal. Vous obtenez donc Number 0au lieu de la vérité booléenne true.

Il s'agit d'une conception de langage vraiment médiocre et c'est l'une des raisons pour lesquelles nous essayons de ne pas utiliser l' ==opérateur malheureux . Utilisez ===plutôt.

// 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.

Vos guillemets autour de la 0font une chaîne, qui est évaluée comme vraie.

Supprimez les guillemets et cela devrait fonctionner.

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

Tout cela est dû aux spécifications ECMA ... en "0" == falseraison des règles spécifiées ici http://ecma262-5.com/ELS5_HTML.htm#Section_11.9.3 ... Et est if ('0')évalué à vrai en raison des règles spécifiées ici http: / /ecma262-5.com/ELS5_HTML.htm#Section_12.5

L'expression "si" teste la véracité, tandis que la double égalité teste l'équivalence indépendante du type. Une chaîne est toujours véridique, comme d'autres l'ont souligné ici. Si le double égal testait la véracité de ses deux opérandes et comparait ensuite les résultats, alors vous obtiendriez le résultat que vous supposiez intuitivement, c'est-à-dire ("0" == true) === true. Comme le dit Doug Crockford dans son excellent JavaScript: les bonnes parties , "les règles par lesquelles [== contraint les types de ses opérandes] sont compliquées et immémoriales ... Le manque de transitivité est alarmant". Il suffit de dire que l'un des opérandes est soumis à une contrainte de type pour correspondre à l'autre, et que "0" finit par être interprété comme un zéro numérique,

== L'opérateur d'égalité évalue les arguments après les avoir convertis en nombres. Ainsi, la chaîne zéro "0" est convertie en type de données Number et la valeur booléenne false est convertie en Number 0. Donc

"0" == false // true

Il en va de même pour `

false == "0" //true

=== Le contrôle d'égalité strict évalue les arguments avec le type de données d'origine

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

Il en va de même pour

false === "0" // false

Dans

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

La chaîne «0» ne se compare à aucun argument et la chaîne est une valeur vraie jusqu'à ce qu'elle soit comparée à un argument ou à moins qu'elle ne soit comparée. C'est exactement comme

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

Mais

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

"

En effet, JavaScript utilise la contrainte de type dans les contextes booléens et votre code

if ("0") 

sera contraint à true dans les contextes booléens.

Il existe d'autres valeurs véridiques dans Javascript qui seront forcées à true dans des contextes booléens, et ainsi exécuter le bloc if sont: -

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) 

force x à utiliser le toBoolean interne de JavaScript (http://es5.github.com/#x9.2)

x == false

contraint les deux côtés en utilisant la contrainte interne toNumber (http://es5.github.com/#x9.3) ou toPrimitive pour les objets (http://es5.github.com/#x9.1)

Pour plus de détails, voir http://javascriptweblog.wordpress.com/2011/02/07/truth-equality-and-javascript/