Différence de performance en JavaScript entre les doubles égaux (==) et les triples égaux (===)

Question

En JavaScript, y a-t-il une différence de performance entre l'utilisation d'un double équivaut ( == ) par rapport à l'utilisation d'une triple égalité ( === ) ?

Exemple : if (foo == bar) vs if (foo === bar)

Answer 1

• Si les types comparés sont les mêmes, ils sont identiques . C'est-à-dire qu'ils utilisent le même algorithme .

• Si les types sont différents alors les performances ne sont pas pertinentes. Soit vous avez besoin de la coercition de type, soit vous n'en avez pas besoin. Si vous n'en avez pas besoin, n'utilisez pas l'option == car le résultat que vous obtenez peut être inattendu.

Answer 2

Comparaison stricte ( === ) sera toujours légèrement plus rapide, mais la différence est généralement négligeable .

Il est logique de préférer === si vous êtes certain que vous n'avez pas besoin de coercition de type dans la comparaison. Elle sera toujours au moins aussi rapide que == .

Answer 3

Edit : pour référence, voici le par la spécification explication par le Dr Axel Rauschmayer http://www.2ality.com/2011/06/javascript-equality.html Très bon article.

=== (Égalité stricte) : Ne considère comme égales que les valeurs qui ont le même type.

1. undefined === undefined, null === null,
2. NaN === rien, y compris lui-même,
3. Primitive [Nombre|Chaîne|Booléen] === valeur primitive égale,
4. à self (+0 === -0)
5. Deux objets [Array|Object|Function] === Seulement soi (même entité exacte)

== (Égalité indulgente)

1. Si les deux valeurs ont le même type : comparer avec ===.
2. undefined == null
3. nombre et chaîne : chaîne => nombre et comparer
4. booléen et non booléen => non booléen vers nombre et comparaison
5. chaîne de caractères ou nombre => un objet : conversion de l'objet en primitive et comparaison.

Dans tous les environnements Javascript modernes, ils sont mis en œuvre de manière complètement différente. En termes simples, == teste l'alikeness en convertissant les variables données en primitives (chaîne, nombre, booléen). === teste la similitude stricte, ce qui signifie que l'objet ou la valeur primitive est exactement le même sans conversion.

Si vous le faites objOne == objTwo ce qui se passe réellement est [[EQUALS]].call(objOne.valueOf(), objTwo.valueOf())

La résolution de valueOf peut être quelque peu compliquée, rebondissant entre des fonctions exposées en JS et des éléments internes du moteur. Il suffit de dire que la comparaison se terminera toujours avec deux valeurs converties en primitives ou une erreur sera envoyée.

Edit : EQUALS essaie réellement STRICT_EQUALS d'abord, ce qui préempte le reste du processus.

Ce qui est intéressant ici, c'est que valueOf (et son partenaire toString) peuvent être remplacés. Exécutez ce morceau de code dans Chrome (je pense que n'importe quel webkit, je ne suis pas sûr que JSC et V8 partagent ce détail). Il vous en mettra plein la vue :

var actions = [];
var overload = {
  valueOf: function(){
    var caller = arguments.callee.caller;
    actions.push({
      operation: caller.name,
      left: caller.arguments[0] === this ? "unknown" : this,
      right: caller.arguments[0]
    });
    return Object.prototype.toString.call(this);
  }
};
overload.toString = overload.valueOf;
overload == 10;
overload === 10;
overload * 10;
10 / overload;
overload in window;
-overload;
+overload;
overload < 5;
overload > 5;
[][overload];
overload == overload;
console.log(actions);

Sortie :

[ { operation: 'EQUALS',
    left: overload,
    right: 10 },
  { operation: 'MUL',
    left: overload,
    right: 10 },
  { operation: 'DIV',
    left: 'unknown',
    right: overload },
  { operation: 'IN',
    left: overload,
    right: DOMWindow },
  { operation: 'UNARY_MINUS',
    left: overload,
    right: undefined },
  { operation: 'TO_NUMBER',
    left: overload,
    right: undefined },
  { operation: 'COMPARE',
    left: overload,
    right: 5 },
  { operation: 'COMPARE',
    left: 'unknown',
    right: overload },
  { operation: 'ToString',
    left: 'unknown',
    right: overload } ]

L'essentiel de la différence entre == y === est illustré par === n'apparaît pas dans cette liste. Il saute entièrement le voyage vers JavascriptLand. Cette aventure est coûteuse lorsqu'on compare les performances.

Cependant, vous devez tenir compte de l'optimisation des moteurs. Pour la plupart des objets, le moteur sera capable de supprimer la plupart des étapes et de rester en NativeLand et d'obtenir presque les mêmes performances. Mais ce n'est pas une garantie et si quelque chose empêche le moteur d'utiliser les optimisations, une certaine fantaisie dans votre code ou le remplacement des builtins ou une myriade de problèmes, alors vous verrez instantanément le résultat en termes de performances. === le force.

=== est à peu près la seule chose immuable en Javascript.

Answer 4

En raison des performances, je pense === a de meilleures performances, car === est plus stricte que == ,

Par exemple, essayez ce qui suit dans la console Chrome.

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

== doit vérifier plus de choses que ===

Answer 5

A partir de quelques tests peu convaincants, == semble être légèrement plus rapide que === .

Par marginalement, je veux dire que je peux voir une différence de quelques millisecondes sur des interations de plusieurs millions de tests. Vous ne pouvez pas avoir besoin du gain de performance, plutôt que d'utiliser ce qui est le plus correct pour la tâche à accomplir.

EDIT : en fait, cela semble dépendre de ce que vous comparez et de l'implémentation du navigateur. En d'autres termes, ne vous inquiétez pas pour ça.