Pourquoi 1 == 1 == 1 retourne true, “1” == “1” == “1” renvoie true et “a” == “a” == “a” renvoie false?

function a() { return (1 == 1 == 1); } function b() { return ("1" == "1" == "1"); } function c() { return ("a" == "a" == "a"); } 

J’ai testé le code ci-dessus dans la console de Chrome et pour une raison quelconque, a() renvoie true, b() renvoie true et c() renvoie false.

Pourquoi cela est-il ainsi?

Parce que vous comparez le résultat (booléen) de la première égalité avec la troisième valeur (non booléenne).

Dans le code, 1 == 1 == 1 est équivalent à (1 == 1) == 1 équivaut à true == 1 .

Cela signifie que les trois méthodes peuvent être écrites plus simplement comme suit:

 function a() { return (true == 1); } function b() { return (true == "1"); } function c() { return (true == "a"); } 

Ces comparaisons fonctionnent selon ces règles (emphase sur la mienne):

Si les deux opérandes ne sont pas du même type, JavaScript convertit les opérandes, puis applique une comparaison ssortingcte. 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 ou l’autre opérande est une chaîne, l’opérande de chaîne est convertie en un nombre si possible. Si les deux opérandes sont des objects, alors JavaScript compare les références internes qui sont égales lorsque des opérandes font référence au même object en mémoire.

Donc, ce qui se passe dans c est que "a" est converti en un nombre (donnant NaN ) et le résultat est ssortingctement comparé à true converti en un nombre (donnant 1 ).

Puisque 1 === NaN est false , la troisième fonction renvoie false . Il est très facile de voir pourquoi les deux premières fonctions retourneront true .

Parce que 1 == true

Mais "a" != true

Donc, fondamentalement, ce qui se passe est que

1 == 1 , "1" == "1" et "a" == "a" sont tous évalués comme étant true et comparés à la valeur suivante.

La chaîne "1" est convertie en nombre ( 1 ) avant d’être comparée à true et est également considérée comme égale à true .

Maintenant, le “POURQUOI?!?!” La question s’explique par le fait que Javascript a ses racines dans la famille des langages en C. Dans lequel tout nombre autre que 0 est considéré comme un true booléen valide. : – /

Parce que 1 et “1” sont tous deux convertis en vrais, sous forme de nombres. Ce n’est pas le cas avec “a”. Donc:

 ("1" == "1" == "1") 

évalue à

 (("1" == "1") == "1") 

qui évalue à

 (true == "1") 

De même,

 ("1" == 1 == "1") 

est également vrai, ou toute combinaison de ceux-ci. En fait, tout nombre non nul converti en booléen est vrai.

Alors que “a” n’est pas considéré comme vrai.

C’est parce que JavaScript est un langage faiblement typé. Cela signifie qu’il n’est pas assez expressif pour parler de types, et contraint implicitement les valeurs à appartenir à des types sans relation sémantique. Donc, (1 == 1) == 1 a la valeur true car (1 == 1) est correctement évalué à true, de sorte que JavaScript évalue (true) = 1. En particulier, il devient 1 en booléen (ou vrai pour un nombre – j’oublie lequel, mais le résultat est effectivement le même).

Le fait est que JavaScript transforme un type de valeur en un autre type de valeur dans votre dos.

Votre question montre pourquoi c’est un problème: (‘a’ == ‘a’) == ‘a’ est faux, car (‘a’ == ‘a’) est vrai et JavaScript finit par comparer (true) = = ‘a’ Comme il n’y a pas de moyen raisonnable de transformer un booléen en une lettre (ou une lettre dans un booléen), cette affirmation est fausse. Bien sûr, cela brise la transparence référentielle pour (==).

C’est vrai que (1 == 1) == 1 . Alors ce sera true == 1 , mais pas dans a == a == a .

Booléen géré comme des bits, chaque bit signifie vrai ou faux (1 pour vrai, 0 pour faux)

pour que 1 soit vrai et 0 pour faux

et 1 == 1 == 1 sera comme (1 == 1) == 1, vrai == 1, vrai

tandis que ‘a’ == ‘a’ == ‘a’ sera (‘a’ == ‘a’) == ‘a’, vrai == ‘a’, faux

BONUS: 0 == 1 == 0, 1 == 0 == 0 et 0 == 0 == 1 renvoie true