Quel opérateur d'égalité (== vs. ===) doit être utilisé dans les comparaisons JavaScript ?

Question

J'utilise JSLint pour explorer JavaScript et il renvoie de nombreuses suggestions pour remplacer == (deux signes égaux) par === signes égaux) lors de l'exécution d'opérations telles que la comparaison de idSele_UNVEHtype.value.length == 0 dans une instruction if

Le remplacement de == par === présente-t-il un avantage en termes de performances ?

Toute amélioration des performances serait la bienvenue car il existe de nombreux opérateurs de comparaison.

Y aura-t-il un gain de performances par rapport à == sans conversion de type ?

Answer 1

Utilisez l'opérateur == (Equal)

true == 1; //true, because 'true' is converted to 1 and then compared
"2" == 2;  //true, because "2" is converted to 2 and then compared

Utilisez l'opérateur === (Identité)

true === 1; //false
"2" === 2;  //false

C'est parce que l'opérateur d'égalité == effectue un cast de type, ce qui signifie que l'interpréteur essaiera implicitement de convertir la valeur avant de comparer.

D'un autre côté, l'opérateur identity === ne fait pas de coercition de type, donc les valeurs ne sont pas converties lors de la comparaison.

Answer 2

L'opérateur d'égalité stricte (===) 的行为与抽象相等运算符 (==) est le même, sauf qu'aucune conversion de type n'est effectuée et que les types doivent être les mêmes pour être considérés comme égaux.

Référence : Tutoriel JavaScript : Opérateurs de comparaison

== 运算符将在进行任何必要的类型转换后比较是否相等。 === 运算符不会进行转换，因此如果两个值不是同一类型，=== 将简单地返回 假. Les deux sont tout aussi rapides.

Citation du grand JavaScript: The Good Parts de Douglas Crockford,

---

Mise à jour

@Casebash dans les commentaires et @Phillipe Laybaert réponse sur les objets. Pour les objets, == 和 === se comportent de manière cohérente les uns par rapport aux autres (sauf cas particuliers).

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 est celui où vous comparez une primitive à un objet qui est évalué comme la même primitive en raison de l'objet chaîne créé par son constructeur toString 或 valueOf 方法。例如，考虑将字符串基元与使用 String.

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

Ici == 运算符检查两个对象的值并返回 true，但是 === 看到它们类型不同并返回 false。哪一个是正确的？这实际上取决于您要比较的内容。我的建议是完全绕过这个问题，只是不要使用 String Le constructeur crée un objet chaîne à partir d'une chaîne littérale.

Référence
https://262.ecma-international.org/5.1/#sec-11.9.3