JavaScript - === vs == performances des opérateurs

Il y A quelques semaines, j'ai lu ce fil ≪ plus rapide que <=? sur les opérateurs de comparaison dans C. Il a été dit qu'il n'y a pas de différence dans les performances entre les < et <= comme elles sont interprétées de la même machine à commandes.

Dans le même temps, dans notre société, les "meilleures pratiques", il a été dit que nous devrions toujours utiliser "===" pour comparer des choses au lieu de "==". Donc, j'ai commencé à me demander si c'est toujours le cas, comme j'ai l'habitude d'utiliser le "==" et "typeof ... ==" et ne veulent pas changer ma façon d'écrire :-]

Noter que c'est dans le contexte de JavaScript.

J'ai une petite recherche et voici Qui est égal à l'opérateur (== vs ===) devrait être utilisé en JavaScript comparaisons? il est dit que:

C'est parce que l'opérateur d'égalité == ne de contrainte de type sens...
que l'interprète implicitement essaie de convertir les valeurs et puis
la comparaison.

D'autre part, l'identité de l'opérateur === ne pas faire de ce type de
la contrainte, et donc il ne permet pas de convertir les valeurs des valeurs
lorsque l'on compare les

Et j'ai commencé à me demander si cela signifie que lorsque j'utilise le "===" opérateur, je vais obtenir de bonnes performances que les ressources ne seront dépensés sur la conversion de l'opérande. Et après tout le code est transformé en machine à commandes, est-ce à dire que, tout comme il n'y a pas de différence dans C lorsque vous utilisez < et <=c'est la même chose en JavaScript et d'autres langages?

source d'informationauteur gotqn

  1. 0

    pour js, l' === opérateur renvoie true si elle est utilisée sur des types de chaînes et les cordes sont exactement les mêmes caractères. Pour les objets, il compare les références de l'objet, pas le contenu.

    De la Standard ECMA:

    11.9.6 L'Égalité Stricte de l'Algorithme de Comparaison La comparaison x === y, où x et y sont des valeurs, produit des vrai ou faux. Une telle comparaison
    est effectué comme suit:

    1. Si Type(x) est différent de Type(y), renvoie false.
    2. Si Type(x) n'est pas défini, return true.
    3. Si Type(x) est Nul, retourne true.
    4. Si Type(x) est le Nombre, puis
      un. Si x est NaN, retourne false.
      b. Si y est NaN, retourne false.
      c. Si x est le même Numéro de valeur y, retourner la valeur true.
      d. Si x est de +0 et y est de -0, retourner la valeur true.
      e. Si x est 0 et y +0, renvoyer true.
      f. De retour faux.
    5. Si Type(x) est une Chaîne, puis retourne true si x et y sont exactement la même séquence de caractères (même longueur et de même caractère dans
      des positions correspondantes); sinon, retourne false.
    6. Si Type(x) est de type Boolean, retourne true si x et y sont les deux vraies ou fausses;
  2. 9

    Tout d'abord, la performance n'est tout simplement pas une préoccupation. Pour tout réel script, aucun gain de performance de l'aide d'un opérateur sur l'autre sera infinitessimally petit comparé à d'autres goulets d'étranglement dans le code (généralement de manipulation du DOM serait la cible numéro un).

    Deuxièmement, dans de nombreux cas, == et === effectuera exactement les mêmes étapes. Lorsque les types des deux opérandes sont identiques (deux chaînes ou deux nombres, par exemple), la spécification ECMAScript a exactement les mêmes étapes pour les deux opérateurs. C'est pourquoi, si vous observez une différence de performance entre les deux opérateurs pour des opérandes de même type dans un navigateur ou d'une autre, il n'y a pas de garantie ou même la probabilité que vous allez voir une différence semblable dans un autre navigateur.

    Dans le cas de typeofcomme mentionné dans votre question, les deux opérandes sont garantis être de même type (string) et les deux opérateurs vont faire exactement la même chose, donc les seules raisons à la faveur d'un opérateur sur l'autre sont stylistique.

    Le JS de la communauté dans son ensemble est passé plutôt intransigeants sur ce point: le consensus semble être "ne jamais utiliser == et != sauf si vous avez besoin de contrainte de type", ce qui est trop dogmatique pour mes goûts.

  3. 3

    Il n'a pas d'importance ce que la performance, === est clairement le meilleur choix dans ce cas. Rien d'autre, comme l'amélioration des performances est juste la cerise sur le gâteau. En outre, la différence est minime.

  4. 3

    C'est un langage de script. La performance de ces opérateurs ne devrait pas tellement importants que vous devriez vous inquiéter à ce sujet, parce qu'il y a un tas d'autres choses qui consomment beaucoup plus de puissance, comme le fait qu'il s'exécute dans une machine virtuelle, ce qui est faible tapé, fonctionne avec un DOM HTML à l'intérieur d'un navigateur...

    En outre, les deux opérateurs de faire des choses très différentes, de sorte que l'un peut ne pas être interchangeables avec les autres en tout cas.

    Cela dit, je pense (mais n'ai pas testé) que === est plus rapide. La raison d'être, qu'il n'a besoin que de comparer le type, et si cela correspond à, de comparer les données brutes. Le == opérateur tente de convertir un type à l'autre si elles ne correspondent pas. Ce sera l'un des plus coûteux dans la plupart des cas.

    Et c'est heureux, parce que dans la plupart des cas === est la meilleure option. 🙂

    Mais de toute façon, vous pouvez facilement tester (assurez-vous de tester plusieurs cas, les deux avec le même type et un couple de différents types), mais si vous ne savez pas comment le tester, j'avais arrêter de s'inquiéter du tout. La différence, le cas échéant, ne va pas vous tuer.

  5. 2

    La différence de performances est négligeable, ce qui signifie que vous ne devriez pas perdre votre précieux cerveau cycles de réflexion à ce sujet. Si vous voulez vraiment savoir, vous devriez tester.

    Utilisation === sauf si vous avez une bonne raison de ne pas (vous n'avez probablement pas).