web-dev-qa-db-fra.com

Différence de performance JavaScript entre double égal (==) et triple égal (===)

En JavaScript, existe-t-il une différence de performances entre l’utilisation d’un double égal (==) et celle d’un triple égal (===)?

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

javascriptnode.jsperformancebrowsercomparison
36
Eric

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

Il est tout à fait logique de préférer === si vous savez avec certitude que vous n’avez pas besoin de coercition dans la comparaison. Ce sera toujours au moins aussi rapide que ==.

26
Dave Ward

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

  • Si les types sont different , les performances ne sont pas pertinentes. Soit vous avez besoin de coercition de type, soit vous n'en avez pas. Si vous n'en avez pas besoin, n'utilisez pas == car le résultat obtenu risque d'être inattendu.

40
user1034768

Edit: pour référence, voici le par la spécification du Dr. Axel Rauschmayer http://www.2ality.com/2011/06/javascript- égalité.html Vraiment super rédiger.

=== (égalité stricte): considère uniquement les valeurs égales du même type.

  1. undefined === undefined, null === null,
  2. NaN === rien y compris lui-même,
  3. Primitive [Number | String | Boolean] === valeur primitive égale,
  4. à soi-même (+0 === -0)
  5. Deux objets [Array | Object | Function] === Uniquement self (même entité exacte)

== (égalité claire)

  1. Si les deux valeurs ont le même type: comparez avec ===.
  2. non défini == null
  3. nombre et chaîne: chaîne => nombre et comparaison
  4. boolean et non-boolean => non-boolean pour numéroter et comparer
  5. chaîne ou nombre => un objet: convertit un objet en primitive et compare.

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

Si vous 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 impliquée, rebondissant entre les fonctions exposées dans JS et les commandes internes du moteur. Autant dire que la comparaison aboutira toujours avec deux valeurs forcées à primitives ou une erreur sera renvoyée.

Edit: EQUALS essaye d’abord le STRICT_EQUALS, ce qui empêche le reste du processus.

Le bit intéressant ici est que valueOf (et son partenaire toString) sont écrasables. Exécutez ce morceau de code dans Chrome (je pense que tout webkit, pas sûr si JSC et V8 partagent cette friandise). Cela va exploser votre état d'esprit:

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’essence de la différence entre == et === est illustrée par === ne figurant pas dans cette liste. Il saute le voyage dans JavascriptLand entièrement. Cette aventure coûte cher en comparant les performances.

Cependant, vous devez tenir compte des optimisations de moteur. Pour la plupart des objets, le moteur sera capable de couper la plupart des marches et de rester dans NativeLand et d'obtenir presque les mêmes performances. Mais cela n’est pas une garantie et si quelque chose empêche le moteur d’utiliser les optimisations, une certaine fantaisie dans votre code ou de remplacer les commandes intégrées ou une multitude de problèmes, vous voyez immédiatement le résultat en termes de performances. === le force.

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

14
user748221

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

par exemple. essayez ce qui suit dans la console Chrome.

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

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

3
James.Xu

== semble être légèrement plus rapide que ===.

De manière marginale, je veux dire que je peux voir une différence de quelques millisecondes sur les interations de plusieurs millions de tests. Vous ne pouvez probablement pas avoir besoin du gain de performance, plutôt que d’utiliser ce qui convient le mieux à la tâche à accomplir.

EDIT: en fait, semble dépendre de/quoi/que vous comparez et de la mise en oeuvre du navigateur. En d'autres termes, ne vous inquiétez pas pour ça.

1
Hamish

Cela dépend des éléments comparés. Puisque "===" est plus strict que "==", il devrait retourner faux plus vite que "==". Cependant, si les deux éléments sont strictement égaux, "===" devrait prendre plus de temps que "==" car il doit vérifier davantage de propriétés pour vérifier leur égalité.

0
Joseph C