JavaScript's Statement Performance Questions

Question

Pouvez-vous m'aider à déterminer la différence de performance de chacune de ces déclarations ? Laquelle des deux utiliserait-on ?

1. Créer un nouveau tableau en utilisant

   - var new_list = new Array();  //or
   - var new_list = [];

2. Ajout d'un élément à l'aide de

   - push('a')
   - new_list[i]; (if i know the length)

3. Opérateur ternaire ou if() {} else (){}

4. Essayer de faire fonctionner isodd, qui est plus rapide

   (! (is_even)) or (x%2!=0)

5. forEach() ou l'itération normale

un de plus

6. a= b = 3; o b=3; a=b;

[Je suis en train de créer une bibliothèque mathématique. Donc toutes les discussions sur les performances sont aussi les bienvenues :) ]

Merci pour votre aide.

Answer 1

J'ai toujours supposé que (x&1) étant une opération par bit, ce serait le moyen le plus rapide de vérifier les nombres pairs/impairs, plutôt que de vérifier le reste du nombre.

Answer 2

Je vous suggère de coder un simple script comme :

for(var i = 0; i < 1000; i++){
  // Test your code here.
}

Vous pouvez faire tout ce que vous voulez de cette manière, en ajoutant éventuellement des fonctions de synchronisation avant et après le for pour être plus précis.

Bien entendu, vous devrez modifier la limite supérieure (1000 dans cet exemple) en fonction de la nature de vos opérations - certaines nécessiteront plus d'itérations, d'autres moins.

Answer 3

Les caractéristiques de performance de tous les navigateurs (en particulier au niveau des fonctions individuelles des bibliothèques) peuvent varier considérablement, il est donc difficile de donner des réponses vraiment significatives à ces questions.

Quoi qu'il en soit, juste en regardant le rapide moteurs js (donc Nitro, TraceMonkey, et V8)

1. [ ] sera plus rapide que new Array -- new Array se transforme en la logique suivante

   1. cons = rechercher la propriété "Array", si elle est introuvable, lancer une exception.
   2. Vérifiez si cons peut être utilisé comme un constructeur, sinon : lancer une exception
   3. thisVal = Le temps d'exécution crée directement un nouvel objet
   4. res = résultat de l'appel cons en passant par thisVal comme valeur pour this -- ce qui nécessite une logique pour distinguer les fonctions JS des fonctions d'exécution standard (en supposant que les fonctions d'exécution standard ne sont pas implémentées en JS, ce qui est le cas normal). Dans ce cas Array est un constructeur natif qui crée et renvoie un nouvel objet tableau d'exécution.
   5. si res est indéfini ou nul alors le résultat final est thisVal sinon le résultat final est res . En cas d'appel Array un nouvel objet tableau sera retourné et thisVal seront jetés

   [ ] indique simplement au moteur JS de créer directement un nouvel objet tableau d'exécution immédiatement, sans logique supplémentaire. Cela signifie que new Array a une grande quantité de logique supplémentaire (pas très bon marché), et effectue une allocation d'objet supplémentaire inutile.

2. newlist[newlist.length] = ... est plus rapide (en particulier si newlist n'est pas un tableau clairsemé), mais push est suffisamment courant pour que je m'attende à ce que les développeurs de moteurs fassent des efforts pour améliorer les performances, de sorte que cette fonction pourrait changement dans le temps.

3. Si vous avez une boucle assez serrée, il peut y avoir un très léger gain pour l'opérateur ternaire, mais on peut soutenir que c'est un défaut de moteur dans le cas trival de a = b ? c : d vs if (b) a = c; else a = d

4. Les frais d'appel de fonction à eux seuls éclipseront le coût de plus ou moins n'importe quel opérateur JS, du moins dans les cas raisonnables (par exemple, si vous effectuez des calculs sur des nombres plutôt que sur des objets).

5. El foreach La syntaxe n'est pas encore standardisée mais sa performance finale dépendra d'un grand nombre de détails. Souvent, la sémantique de JS fait que des déclarations d'apparence efficace sont moins efficaces -- par exemple. for (var i in array) ... est beaucoup plus lent que for (var i = 0; i < array.length; i++) ... comme le veut la sémantique JS in pour établir une liste de toutes les propriétés de l'objet (y compris la chaîne de prototypes), et puis vérifier que chaque propriété est toujours présente sur l'objet avant de l'envoyer dans la boucle. Oh, et les propriétés doivent être converties d'entiers (dans le cas d'un tableau) en chaînes de caractères, ce qui coûte du temps et de la mémoire.

Answer 4

1. Les deux sont des constructeurs natifs, probablement aucune différence.
2. push est plus rapide, il correspond directement au natif, alors que [] est évaluatif.
3. Il n'y a probablement pas une grande différence, mais techniquement, ils ne font pas la même chose, donc ce n'est pas du tout pareil.
4. x%2, saute l'appel de fonction qui est relativement lent
5. J'ai entendu dire, mais je ne trouve pas le lien pour le moment, que l'itération est plus rapide que le foreach, ce qui m'a surpris.

Edit : Sur #5, je crois que la raison est liée à este En effet, foreach est ordonné vers l'avant, ce qui oblige l'incrémenteur à compter vers l'avant, alors que les boucles for sont infiniment plus rapides lorsqu'elles sont exécutées vers l'arrière :

for(var i=a.length;i>-1;i--) {
    // do whatever
}

ce qui précède est légèrement plus rapide que :

for(var i=0;i<a.length;i++) {
    // do whatever
}

Answer 5

Comme l'ont suggéré d'autres posters, je pense que le mieux est de faire des tests comparatifs... Cependant, j'aimerais aussi noter que vous obtiendrez probablement des résultats très différents avec différents navigateurs, car je suis sûr que la plupart des questions que vous posez concernent l'implémentation interne spécifique des constructions du langage plutôt que le langage lui-même.