Pourquoi [] + {} === {} + [] est-il vrai?

Question

Si vous ouvrez votre JS console et tapez [] + {} === {} + [] il vous dit qu'il est vrai.

Je ne comprends pas pourquoi c'est. J'ai essayé de regarder comment c'est analysée.

Pour [] + {} le + ici est l'opérateur d'addition comme opérandes sont les deux littéraux. LHS ne donne pas un nombre en .valueOf() alors qu'il effectue la concaténation de chaîne à l'aide de .toString() sur les deux opérandes nous donner des "" + "[object Object]"

Pour {} + [] le {} est vide bloc de code est "ignoré", l' + opérateur est ici analysée comme unaire opérateur plus, il convertit son opérande pour un certain Nombre. Des tableaux vides converties en un nombre devenue 0

C'est donc ce qui semble être "[object Object]" === 0 qui ne devrait certainement être faux?.

L'identité de l'opérateur vérifie si les deux opérandes sont égaux sans conversion de type. Je ne vois pas comment ce petit plus ponctuellement être vrai. Quelle partie de l'histoire qui me manque?

Edit:

- Je voir si vous tapez ({} + []) il analyse comme un objet vide faisant le membre de droite de l'égalité à "[object object]". J'ai regardé ce et ( ) , c'est le regroupement de l'opérateur. Alors peut-être que cela a quelque chose à voir avec cela?

Ce n'est pas un doublon de Ce qui est l'explication de ces bizarres JavaScript comportements mentionnés dans le " Wat " parler pour CodeMash 2012?. Réponse de points de balle 1 === 2 ne devrait PAS être vrai.

Answer 1

Le deuxième point dans cette magnifique réponse explique ce qui se passe quand vous "ajouter" un tableau et d'un objet.

var result = [] + {};

console.log(result);
console.log(typeof result);

Ce que vous obtenez est la chaîne de caractères [object Object] parce que chacun de ces arguments est converti en chaîne de caractères. Pour un tableau, que les résultats de l'appel .join() sur, ce qui, à son tour, entraîne une chaîne vide. Pour les Objets, il produit la chaîne "[object Object]" - ajouter ensemble les feuilles de la deuxième chaîne.

Le même phénomène se produit sur les deux côtés de la comparaison sur le côté droit, l'ordre est différent, mais qui n'a pas d'importance. Le résultat va pas être la même que pour le point 3 dans la réponse, car la différence est qu'il y {} + [] est au début de la ligne, {} est interprété comme un bloc vide. Dans cette situation, il sera (bien) être interprété comme un simple object notation). Le même casting logique sera effectué et qu'il va produire la même chaîne comme avant: "[object Object]"

Donc, en fin de compte, vous êtes en comparant "[object Object]" === "[object Object]" qui renvoie true.

Notez que {} + [] === [] + {} sera pas produire les mêmes - encore une fois, en raison du point 3 de la réponse - la première {} sera interprété comme un bloc vide, de sorte que le côté gauche devient +[] qui convertit le tableau pour un certain nombre, d'où le résultat de la comparaison sera false. Toutefois , si vous testez cette expression dans le Chrome dev tools, vous aurez en effet se true. C'est parce que google Chrome auto-enveloppez votre expression entre parenthèses , ce qui oblige l'initiale {} d'être interprétée comme un objet. Vérification de l' {} + [] === [] + {} dans Firefox ou Nœud REPL ou autres, devrait permettre de "corriger" false.

Answer 2

    var array = ['test1', 'test2', 'test3']
    var emptyObject = {}

    console.log(typeof(array+emptyObject));
    console.log(array+emptyObject);
    console.log(emptyObject+array);
    console.log(array+emptyObject === emptyObject+array);

    var array = [];
    var emptyObject = {}

    console.log(typeof(array+emptyObject));
    console.log(array+emptyObject);
    console.log(emptyObject+array);
    console.log(array+emptyObject === emptyObject+array);

    var array = ['firstArrayElement', 'secondArrayElement'];
    var object = {a:1, b:2}
    
    console.log(typeof(array+object));
    console.log(array+object);
    console.log(object+array);
    console.log(array+object === object+array);

    console.log(['a','b']+['c','d']);

Lorsque vous convertissez un tableau vide à la chaîne, vous recevrez une chaîne vide.

Lorsque vous convertissez un objet({}) à la chaîne, vous recevrez toujours de la chaîne: "[object object]".

En Plus de l'opérateur n'est pas définie pour les tableaux et les objets afin de JS toujours convertir le tableau et l'objet de chaîne lorsque vous utilisez l'opérateur plus.