En JS, ce qui est plus rapide: Objet de l'opérateur “in” ou de la Matrice indexof?

En JavaScript, vous êtes généralement affaire à une grande variété de mises en œuvre (sauf si vous l'utilisez dans un environnement contrôlé comme un serveur où vous choisissez le moteur), et donc, la réponse spécifique des questions de performances ont tendance à être "ça dépend, vérifier sur les moteurs que vous allez utiliser." Ce qui est plus rapide sur une mise en œuvre peut être plus lent sur un autre, etc. http://jsperf.com est pratique pour ce genre de chose.

Cela dit, je m'attends à ce in pour être un gagnant clair ici. Array#indexOf a accéder au tableau d'index dans une recherche, et les indices de tableau sont des propriétés comme toute autre propriété. L'accès à d'index de tableau 0 pour voir si c'est la chaîne souhaitée, il faut examiner jusqu' 0 tout comme les autres nécessite la recherche de la propriété "canSummonKraken" (et puis il doit faire une comparaison de chaîne par la suite). (Oui, les indices de tableau sont des propriétés. Les tableaux en JavaScript ne sont pas vraiment des tableaux à tous.) Et indexOf peut avoir accès à plusieurs de ces propriétés au cours de sa recherche, alors que in n'aurez qu'à en avoir un. Mais encore une fois, vous aurez besoin de vérifier dans votre cible environemnts pour être sûr, certaines implémentations peuvent optimiser les tableaux qui ont contiguë indice va (mais plus lentes certainement n'avez pas, et bien sûr, si vous êtes inquiet au sujet de la vitesse, vous êtes inquiet au sujet de ce qui est le plus rapide à la plus lente des moteurs, comme IE).

Également noter que tous les moteurs JavaScript ont même Array#indexOf encore. La plupart le font, mais il y a encore quelques anciens coups de pied autour (je suis à la recherche à vous, Microsoft) qui ne sont pas.

Vous avez également la question de savoir si l'utilisation in ou hasOwnProperty. À l'aide de in a l'avantage que c'est un opérateur, de ne pas l'appel de la fonction; à l'aide de hasOwnProperty a l'avantage qu'il ne vous regardez à l'objet spécifique de l'instance et non de son prototype (et son prototype, etc.). Sauf si vous avez un très profondément hérité de la hiérarchie (et vous n'avez pas dans votre exemple), je parie in victoires, mais il est utile de rappeler qu'il ne vérifie pas la hiérarchie.

Aussi, n'oubliez pas que "canSummonKraken" in obj sera vrai dans l'exemple littéral d'objet vous a montré, parce que l'objet n'en avoir la propriété, même si la valeur de la propriété est null. Vous avez de ne pas avoir la propriété à tous les pour en retourner false. (Au lieu de in, vous pouvez simplement utiliser le vrai et le faux et le regarder comme obj.canSummonKraken.)

Afin que vos options sont les suivantes:

1. Votre méthode de tableau:

   corporatePlan = [
       'canDeAuthorize',
       'hasGmailSupport',
       'canShareReports',
       'canSummonKraken',
       'etc'
   ];
   
   console.log(corporatePlan.indexOf("canSummonKraken") >= 0);  //true
   console.log(corporatePlan.indexOf("canDismissKraken") >= 0); //false

   ...je ne le recommande pas.

2. La in méthode:

   corporatePlan = {
       'canDeAuthorize'  : null,
       'hasGmailSupport' : null,
       'canShareReports' : null,
       'canSummonKraken' : null,
       'etc'             : null
   };
   
   console.log("canSummonKraken" in corporatePlan);  //true
   console.log("canDismissKraken" in corporatePlan); //false

   Probablement plus rapide que la indexOf, mais j'aimerais le tester. Utile si la liste pourrait être très longue et si vous allez avoir un grand nombre de ces objets, car il exige seulement que le "truthy" propriétés existent à tous. Un objet vide représente un plan où l'utilisateur ne peut pas tout faire, et il est relativement petit.

   Je note deux choses ici:

   1. in vérifie le prototype de l'objet, ainsi, si vous avez eu des paramètres comme toString ou valueOf, vous souhaitez obtenir de faux positifs (comme ceux qui sont propriétés près de tous les objets de Object.prototype). Sur un ES5 est activé sur votre navigateur, vous pouvez éviter ce problème en créant votre objet avec un null prototype: var corporatePlan = Object.create(null);

   2. Peut-être parce qu'il vérifie les prototypes, les in opérateur est étonnamment lent sur certains moteurs.

   Ces deux problèmes peuvent être résolus en utilisant hasOwnProperty à la place:

   console.log(corporatePlan.hasOwnProperty("canSummonKraken"));  //true
   console.log(corporatePlan.hasOwnProperty("canDismissKraken")); //false

   On pourrait penser à un opérateur d'être plus rapide qu'un appel de méthode, mais il s'avère que c'est pas fiable de la vraie-croix-navigateur.

3. Les drapeaux de la méthode:

   corporatePlan = {
       'canDeAuthorize'   : true,
       'hasGmailSupport'  : true,
       'canShareReports'  : true,
       'canSummonKraken'  : true,
       'canDismissKraken' : false,
       'etc'              : true
   };
   
   console.log(corporatePlan.canSummonKraken);  //"true"
   console.log(corporatePlan.canDismissKraken); //"false"
   
   //or using bracketed notation, in case you need to test this
   //dynamically
   console.log(corporatePlan["canSummonKraken"]);  //"true"
   console.log(corporatePlan["canDismissKraken"]); //"false"
   
   //example dynamic check:
   var item;
   item = "canSummonKraken";
   console.log(corporatePlan[item]);  //"true"
   item = "canDismissKraken";
   console.log(corporatePlan[item]);  //"false"

   ...qui serait assez normal de chemin à faire, probablement plus rapide que in, et probablement au moins aussi vite que hasOwnProperty. (Mais voir mon paragraphe d'ouverture: de Test dans votre environnement. 🙂 )

Ici est une référence http://jsperf.com/array-indexof-vs-object-keys.
Dans chrome et firefox, de vérifier la présence d'une clé dans l'objet est 100% plus rapide que l'analyse de la matrice.

Mais si vous prenez le temps d'initialisation en compte, la différence annule, des objets prend de façon de plus de temps pour initialiser que les tableaux.