Qui est égal à l'opérateur (== vs ===) devrait être utilisé en JavaScript comparaisons?

L'identité (===) opérateur se comporte de manière identique à l'égalité (==) opérateur sauf pas de conversion de type est fait, et les types doivent être identiques pour être considérés comme égaux.

Référence: Javascript Tutoriel: Les Opérateurs De Comparaison

La == opérateur de comparer pour l'égalité après avoir fait toute les conversions de type. Le === opérateur pas faire la conversion, de sorte que si les deux valeurs ne sont pas du même type === renvoie simplement false. Les deux sont tout aussi rapide.

À la citation de Douglas Crockford excellent JavaScript: Les Bonnes Parties,

JavaScript a deux ensembles d'opérateurs d'égalité: === et !==, et leurs jumeaux maléfiques == et !=. Les bons de travail de la façon que vous attendez. Si les deux opérandes sont de même type et ont la même valeur, alors === produit true et !== produit false. Les evil twins faire la bonne chose quand les opérandes sont de même type, mais si elles sont de différents types, ils tentent de forcer les valeurs. les règles par lesquelles ils ne sont complexes et immémorial. Ces sont quelques-uns des cas intéressants:

'' == '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

Le manque de transitivité est alarmant. Mon conseil est de ne jamais utiliser les evil twins. Au lieu de cela, utilisez toujours === et !==. Toutes les comparaisons qui vient de montrer produire false avec le === opérateur.

---

Mise à jour:

Un bon point a été évoqué par @Casebash dans les commentaires et dans @Phillipe Laybaert de l' réponse concernant les types de référence. Pour les types référence == et === agir de manière cohérente avec l'un de l'autre (sauf dans un cas particulier).

var a = [1,2,3];
var b = [1,2,3];

var c = { x: 1, y: 2 };
var d = { x: 1, y: 2 };

var e = "text";
var f = "te" + "xt";

a == b            //false
a === b           //false

c == d            //false
c === d           //false

e == f            //true
e === f           //true

Le cas particulier, c'est quand vous comparez un littéral avec un objet qui donne la même littéral, en raison de sa toString ou valueOf méthode. Considérons, par exemple, la comparaison d'un littéral de chaîne avec une chaîne de caractères de l'objet créé par l' String constructeur.

"abc" == new String("abc")    //true
"abc" === new String("abc")   //false

Ici la == opérateur est en train de vérifier les valeurs des deux objets, et le retour true, mais le ===, c'est de voir qu'ils ne sont pas du même type et de retour false. Laquelle est la bonne? Cela dépend vraiment de ce que vous êtes en train de comparer. Mon conseil est de contourner la chose, et il suffit de ne pas utiliser le String constructeur pour créer des objets string.

Référence

http://www.ecma-international.org/ecma-262/5.1/#sec-11.9.3

OriginalL'auteur Bill the Lizard

Une intéressante représentation picturale de la comparaison d'égalité entre == et ===.

Source: http://dorey.github.io/JavaScript-Equality-Table/

---

var1 === var2

Lors de l'utilisation de === pour JavaScript égalité d'essais, tout est comme il est. Rien ne se convertis avant d'être évalués.

---

var1 == var2

Lors de l'utilisation de == JavaScript pour l'égalité des tests, certains
funky conversions lieu.

Morale de l'histoire:

Utilisation === si vous ne comprenez pas l'
les conversions qui ont lieu avec ==.

OriginalL'auteur SNag

Permettez-moi d'ajouter ce conseil:

En cas de doute, lisez l' spécification!

ECMA-262 est la spécification d'un langage de script dont le JavaScript est un dialecte. Bien sûr, dans la pratique, il est plus important comment les navigateurs les plus importants comporter que ésotérique définition de la façon dont quelque chose est censé être manipulé. Mais il est utile de comprendre pourquoi new String ("") ! = = "un".

S'il vous plaît laissez-moi vous expliquer comment lire le cahier des charges pour clarifier cette question. Je vois que dans ce très vieux sujet, personne n'avait de réponse pour le très étrange en effet. Donc, si vous pouvez lire un cahier des charges, cela vous aidera dans votre profession énormément. C'est un acquis de compétences. Donc, nous allons continuer.

Une recherche dans le fichier PDF pour l' === m'amène à la page 56 du cahier des charges: 11.9.4. La Stricte Opérateur = ( = = = ), et après patauger dans la specificationalese j'ai trouver:

11.9.6 L'Égalité Stricte De L'Algorithme De Comparaison

La comparaison x === y, où x et y sont des valeurs, produit vrai ou faux. Une telle comparaison est effectuée comme suit:

  1. Si le Type(x) est différent de Type(y), retour faux.

  2. Si le Type(x) n'est pas défini, le retour vrai.

  3. Si le Type(x) est Nulle, retour vrai.

  4. Si le Type(x) n'est pas le Numéro, passez à l'étape 11.

  5. Si x est NaN, retour faux.

  6. Si y est NaN, retour faux.

  7. Si x est le même numéro de valeur y, retour vrai.

  8. Si x est de +0 et y est de -0, retour vrai.

  9. Si x est 0 et y +0, retour vrai.

  10. Retour faux.

  11. Si le Type(x) est une Chaîne, puis retour vrai si x et y sont exactement la même séquence de caractères (même longueur et de même les personnages dans des positions correspondantes); sinon, le retour faux.

  12. Si le Type(x) est de type Boolean, retour vrai si x et y sont deux vrai ou les deux faux; sinon, retour faux.

  13. Retour vrai si x et y désignent le même objet ou si elles se rapportent à des objets joints l'un à l'autre (voir 13.1.2). Sinon, retour faux.

Intéressant, c'est l'étape 11. Oui, les chaînes sont traités comme des types de valeur. Mais cela n'explique pas pourquoi new String ("") ! = = "un". Nous avons un navigateur qui n'est pas conforme à l'ECMA-262?

Pas si vite!

Nous allons vérifier les types des opérandes. L'essayer pour vous-même en les enveloppant dans typeof(). Je trouve que new String("un") est un objet, et à l'étape 1 est utilisé: retour faux si les types sont différents.

Si vous vous demandez pourquoi new String("un") ne pas retourner une chaîne de caractères, comment au sujet de l'exercice de la lecture d'un cahier des charges? Amusez-vous!

---

Aidiakapi l'a écrit dans un commentaire ci-dessous:

À partir de la spécification

11.2.2 Le nouvel Opérateur:

Si Type(constructeur) n'est pas l'Objet, de lancer une exception TypeError.

Avec d'autres mots, si la Chaîne ne serait pas de type d'Objet, il ne peut pas être utilisée avec l'opérateur new.

nouveau renvoie toujours à un Objet, même pour Chaîne constructeurs, trop. Et hélas! La valeur sémantique de chaînes de caractères (voir l'étape 11) est perdu.

Et c'est enfin: new String ("") ! = = "un".

OriginalL'auteur nalply

J'ai testé dans Firefox avec Firebug à l'aide de code comme ceci:

console.time("testEquality");
var n = 0;
while(true) {
    n++;
    if(n==100000) 
        break;
}
console.timeEnd("testEquality");

et

console.time("testTypeEquality");
var n = 0;
while(true) {
    n++;
    if(n===100000) 
        break;
}
console.timeEnd("testTypeEquality");

Mes résultats (testé cinq fois chaque et de en moyenne):

==: 115.2
===: 114.4

Donc, je dirais que la différence infime (c'est plus de 100000 itérations, rappelez-vous) est négligeable. Performance n'est pas une raison de faire ===. Type de sécurité (bien, aussi sûr que vous allez obtenir en JavaScript), et la qualité du code est.

OriginalL'auteur Simon Scarfe

La === opérateur est appelé un opérateur de comparaison stricte, il ne diffèrent de la == opérateur.

Permet de prendre 2 vars a et b.

Pour "a == b" à évaluer à vrai a et b doivent être les même valeur.

Dans le cas de " = = = b" a et b doit être le même valeur et aussi la même type pour évaluer la valeur true.

Prendre l'exemple suivant

var a = 1;
var b = "1";

if (a == b) //evaluates to true as a and b are both 1
{
    alert("a == b");
}

if (a === b) //evaluates to false as a is not the same type as b
{
    alert("a === b");
}

En résumé; à l'aide de la == opérateur peut évaluer à vrai dans les situations où vous ne voulez pas qu'il sorte à l'aide de la === opérateur serait plus sûr.

Dans les 90% d'utilisation du scénario, il ne sera pas question celui que vous utilisez, mais il est pratique de savoir à l'écart quand vous obtenez un certain comportement inattendu d'un jour.

OriginalL'auteur Doctor Jones

Pourquoi == est si imprévisible?

Ce que vous obtenez lorsque vous comparez une chaîne vide "" avec le nombre zéro 0?

true

Yep, c'est juste selon == une chaîne vide et le nombre de zéro sont les mêmes temps.

Et il ne s'arrête pas là, en voici une autre:

'0' == false //true

Les choses deviennent vraiment bizarre avec les tableaux.

[1] == true //true
[] == false //true
[[]] == false //true
[0] == false //true

Alors encore plus bizarre, avec des chaînes

[1,2,3] == '1,2,3' //true - REALLY?!
'\r\n\t' == 0 //true - Come on!

C'est pire:

Quand est égal à égal?

let A = ''  //empty string
let B = 0   //zero
let C = '0' //zero string

A == B //true - ok... 
B == C //true - so far so good...
A == C //**FALSE** - Plot twist!

Permettez-moi de le répéter:

(A == B) && (B == C) //true
(A == C) //**FALSE**

Et c'est juste le truc de dingue que vous obtenez avec les primitives.

C'est un tout nouveau niveau de fou lorsque vous utilisez == avec les objets.

À ce stade, votre demandez probablement...

Pourquoi cela se produit?

Eh bien, c'est parce que contrairement à la "triple égaux" (===) qui vérifie juste si deux valeurs sont les mêmes.

== un tas d'autres trucs.

Il a un traitement spécial pour les fonctions, le traitement spécial pour les valeurs null, undefined, chaînes, you name it.

Elle est assez loufoque.

En fait, si vous avez essayé d'écrire une fonction qui fait ce que == t-il ressemblerait à quelque chose comme ceci:

function isEqual(x, y) { //if `==` were a function
if(typeof y === typeof x) return y === x;
//treat null and undefined the same
var xIsNothing = (y === undefined) || (y === null);
var yIsNothing = (x === undefined) || (x === null);
if(xIsNothing || yIsNothing) return (xIsNothing && yIsNothing);
if(typeof y === "function" || typeof x === "function") {
//if either value is a string 
//convert the function into a string and compare
if(typeof x === "string") {
return x === y.toString();
} else if(typeof y === "string") {
return x.toString() === y;
} 
return false;
}
if(typeof x === "object") x = toPrimitive(x);
if(typeof y === "object") y = toPrimitive(y);
if(typeof y === typeof x) return y === x;
//convert x and y into numbers if they are not already use the "+" trick
if(typeof x !== "number") x = +x;
if(typeof y !== "number") y = +y;
//actually the real `==` is even more complicated than this, especially in ES6
return x === y;
}
function toPrimitive(obj) {
var value = obj.valueOf();
if(obj !== value) return value;
return obj.toString();
}

Alors qu'est-ce que cela signifie?

Cela signifie == est compliqué.

Parce que c'est compliqué, il est difficile de savoir ce qui va se passer quand vous l'utilisez.

Qui signifie que vous pouvez vous retrouver avec des bugs.

Donc la morale de l'histoire est...

Rendre votre vie moins compliquée.

Utilisation === au lieu de ==.

La Fin.

OriginalL'auteur Luis Perez

JavaScript === vs == .

0==false   //true
0===false  //false, because they are of a different type
1=="1"     //true, auto type coercion
1==="1"    //false, because they are of a different type

OriginalL'auteur

Dans un script typique il n'y aura pas de différence de performances. Plus important est peut-être le fait que des milliers de "===" est 1 KO plus lourd que mille "==" 🙂 JavaScript profileurs peut vous dire si il y a une différence de performance dans votre cas.

Mais personnellement, je ferais ce que JSLint suggère. Cette recommandation n'est-il pas raison de problèmes de performances, mais en raison de contrainte de type moyen ('\t\r\n' == 0) est vrai.

OriginalL'auteur Constantin

Il n'y a pas de différence de performances entre les deux opérations dans votre utilisation. Il n'y a pas de conversion de type à faire parce que les deux paramètres sont déjà le même type. Les deux opérations ont un type de comparaison suivie par une comparaison de la valeur.

OriginalL'auteur Sean

=== opérateur vérifie les valeurs ainsi que les types des variables pour l'égalité.

== opérateur vérifie juste la valeur des variables pour l'égalité.

OriginalL'auteur Niraj CHoubey

JSLint parfois vous donne irréaliste de raisons de modifier des trucs. === a exactement le même rendement que == si les types sont déjà les mêmes.

Il est plus rapide que lorsque les types ne sont pas les mêmes, auquel cas il n'essaie pas de convertir les types, mais directement renvoie une valeur false.

Donc, à mon humble avis, JSLint peut-être utilisé pour écrire du nouveau code, mais il est inutile de sur-optimisation qui doit être évité à tous les frais.

Sens, il n'y a pas de raison de changer == à === dans une case comme if (a == 'test') quand vous savez pour un fait que l'un ne peut être qu'une Chaîne de caractères.

De la modification d'une quantité de code de cette façon, les déchets des développeurs et des évaluateurs de temps et ne réalise rien.

OriginalL'auteur ashes

Un exemple simple est

2 == '2'  -> true, values are SAME because of type conversion.
2 === '2'  -> false, values are NOT SAME because of no type conversion.

OriginalL'auteur Vikas

Le top 2 réponses à la fois mentionné == signifie l'égalité et de l' === signifie l'identité. Malheureusement, cette affirmation est inexacte.

Si les deux opérandes de l' == sont des objets, alors qu'ils sont comparées pour voir si elles sont le même objet. Si les deux opérandes pointent vers le même objet, alors l'égalité de l'opérateur retourne true. Sinon,
les deux ne sont pas égaux.

var a = [1, 2, 3];  
var b = [1, 2, 3];  
console.log(a == b)  //false  
console.log(a === b) //false  

Dans le code ci-dessus, = = et === get faux car a et b ne sont pas les mêmes objets.

C'est-à-dire: si les deux opérandes de l' == sont des objets, == se comporte même comme ===, ce qui signifie aussi l'identité. La différence essentielle de ces deux opérateurs est à propos de la conversion de type. == a la conversion avant qu'il vérifie l'égalité, mais === ne pas.

OriginalL'auteur Harry He

De la base de référence javascript

=== Retourne true si les opérandes sont strictement égales (voir ci-dessus)
avec aucune conversion de type.

OriginalL'auteur Paul Butcher

*Opérateurs === vs == *

1 == true    =>    true
true == true    =>    true
1 === true    =>    false
true === true    =>    true

OriginalL'auteur Mr.G