JavaScript opérateurs de comparaison:L'identité vsL'égalité

Question

J'ai essayé de comprendre la différence entre JavaScript opérateurs de comparaison:de l'identité et de l'égalité.De ce que j'ai lu, si vous vérifier l'égalité de deux objets à l'aide de ==, JavaScript, essayez de déterminer si elles sont du même type et, si non, essayez d'obtenir à ce même type.Cependant, === ne se comportent pas de la même manière.Ainsi, à titre d'exemple:

var n = "1";
console.log(n==1);        // outputs true
console.log(n===1);       // outputs false

Quelle est donc la différence entre ces "identité" des opérateurs et des opérateurs d'égalité?Quel est l'avantage d'avoir les deux?

Existe t il des différences dans la performance?Je pense que l'identité de l'opérateur serait plus rapide car il ne fait pas de conversion.

Aussi, comment ces différents quand il s'agit d'objets plus complexes, comme des tableaux?Le plus important, ce n'conventions de dire à propos de quand on doit être utilisé sur d'autres, pourquoi?

Answer 1

L'opérateur d'égalité tentera de rendre les types de données les mêmes avant de faire la comparaison.D'autre part, l'opérateur d'identité exige que les deux types de données soient identiques à une condition préalable.

Il y a pas mal d'autres articles là-bas similaires à ces questions.Voir:

Comment faire l'égalité PHP (== double équivaut) et identité (=== Triple Equals) Les opérateurs de comparaison diffèrent? (a un beau tableau de comparaison)
quel que soit l'opérateur (== VS===)être utilisé dans les comparaisons JavaScript?

En pratique, l'opérateur d'identité est très pratique lorsque vous souhaitez être certain qu'une valeur booléenne est vraie ou fausse depuis ...

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

Answer 2

La différence est que==, <=,>= et!= Do Type Type coercition - par exemple, forcer une chaîne à évaluer en tant que numéro.===, <==,>==, et!== ne fonctionnera pas la coercition.Ils compareront une chaîne à un numéro et, étant donné que la chaîne "1" n'est pas la même que la valeur numérique 1, le résultat est faux.

référence est ici:
https://developer.mozilla.org/fr/javascript/reference/Operators/comparison_opérateurs

Answer 3

== est la même chose que ===, sauf que == n'conversion de type

Pour vous montrer ce que je veux dire ici est une fonction JavaScript qui se comporte exactement comme ==:

// loseEqual() behaves just like `==`
function loseEqual(x, y) {
    // notice the function only uses "strict" operators 
    // like `===` and `!==` to do comparisons

    if(typeof y === typeof x) return y === x;

    if(typeof y === "function" || typeof x === "function") return false;

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

    return x === y;
}

function toPrimitive(obj) {
    var value = obj.valueOf();
    if(obj !== value) return value;
    return obj.toString();
}

Cette fonction devrait aider à expliquer pourquoi les gens continuent à dire que vous ne devriez pas utiliser ==.

Comme vous pouvez le voir == a beaucoup de logique compliquée pour la conversion de type.De ce fait, il est difficile de prédire ce résultat que vous allez obtenir, ce qui peut conduire à des bugs.

Voici quelques exemples de certains des résultats que vous ne s'attendrait pas:

Vérités Inattendues

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

'\r\n\t' == 0 // returns true

Des Conclusions Inattendues

// IF an empty string '' is equal to the number zero (0)
'' == 0 // return true

// AND the string zero '0' is equal to the number zero (0)
'0' == 0 // return true

// THEN an empty string must be equal to the string zero '0'
'' == '0' // returns **FALSE**

Les objets avec des Fonctions Spéciales

// Below are examples of objects that
// implement `valueOf()` and `toString()`

var objTest = {
    toString: function() {
        return "test";
    }
};

var obj100 = {
    valueOf: function() {
        return 100;
    }
};

var objTest100 = {
    toString: function() {
        return "test";
    },
    valueOf: function() {
        return 100;
    }
};

objTest == "test" // returns true
obj100 == 100 // returns true
objTest100 == 100 // returns true

objTest100 == "test" // returns **FALSE**

Answer 4

La raison est que l'identité ou l'opérateur strict (===), il se compare sans conversion de type, ce qui signifie que si les deux valeurs n'ont pas la même valeur et le même type, ils ne seront pas considérés comme égaux.

Une explication plus claire dans le lien suivant:

https:// moyenne.com/@ududico8/ididentity-vs-equality-Battle-of-unStanding-vs-758d396E922#.hhg396ey9