pour en vs Objet.clé forEach sans propriétés héritées

node.js utilise V8, bien que je pense que ce n'est pas la même que la version actuelle dans Chrome, mais je suppose que c'est un bon indicateur de nœud performances sur le sujet.

Secondairement, vous êtes à l'aide de forEach, ce qui est très pratique lors du développement, mais ajoute une fonction de rappel pour chaque itération, et c'est une (relativement) lenghty tâche. Donc, si vous êtes intéressé dans les spectacles, pourquoi ne pas simplement utiliser une normale for boucle?

for (var i = 0, keys = Object.keys(object); i < keys.length; i++) {
    //...
}

Cela donne les meilleures performances, vous pouvez obtenir, la résolution de vos problèmes de vitesse dans Safari aussi.

En bref: ce n'est pas le conditionnel, c'est l'appel à hasOwnProperty qui fait la différence. Vous êtes en train de faire un appel de fonction à chaque itération, c'est pourquoi for...in devient plus lent.

Je me suis intéressé à cette question aujourd'hui, en tant que bien, mais surtout parce que je n'aime pas avoir à tester avec hasOwnProperty de passe par défaut de la charpie quand je sais déjà que mes objets sont propres (comme ils l'ont été créés à partir d'objets littéraux). De toute façon, j'ai élargi un peu sur la réponse de @styonsk pour inclure un meilleur rendement et d'exécuter plusieurs tests et de retour de la sortie.

Conclusion: C'est compliqué pour le nœud. Le meilleur moment ressemble à l'aide de l'Objet.les touches() avec un numérique boucle for ou une boucle while sur nodejs v4.6.1. Sur v4.6.1, la forIn boucle avec hasOwnProperty est la méthode la plus lente. Cependant, sur le nœud v6.9.1 il est le plus rapide, mais il est encore plus lent que les deux Objets.les touches() itérateurs sur v4.6.1.

Notes: Cela a été exécuté sur une fin de 2013, le MacBook Pro avec 16 GO de ram et un 2.4 Ghz i5. Chaque test rattachée à 100% d'un seul processeur pour la durée de l'essai et avait une moyenne rss d'environ 500 mo et a culminé à 1 go de rss. Espérons que cela aide quelqu'un.

Ici mes résultats sont en cours d'exécution contre nodejs v6.9.1 et v4.6.1 avec de gros objets (10^6 propriétés) et des petits objets(50 propriétés)

Nœud v4.6.1 avec grand objet 10^6 propriétés

testObjKeyWhileDecrement
Test Count: 100
Temps Total: 57595 ms
Durée moyenne: 575.95 ms

testObjKeyForLoop
Test Count: 100
Temps Total: 54885 ms
Durée moyenne: 548.85 ms

testForInLoop
Test Count: 100
Temps Total: 86448 ms
Durée moyenne: 864.48 ms

Nœud v4.6.1 avec petit objet de 50 propriétés

testObjKeyWhileDecrement
Test Count: 1000
Temps Total: 4 ms
Durée moyenne: 0.004 ms

testObjKeyForLoop
Test Count: 1000
Temps Total: 4 ms
Durée moyenne: 0.004 ms

testForInLoop
Test Count: 1000
Temps Total: 14 ms
Durée moyenne: 0.014 ms

Nœud v6.9.1 avec grand objet 10^6 propriétés

testObjKeyWhileDecrement
Test Count: 100
Temps Total: 94252 ms
Durée moyenne: 942.52 ms

testObjKeyForLoop
Test Count: 100
Temps Total: 92342 ms
Durée moyenne: 923.42 ms

testForInLoop
Test Count: 100
Temps Total: 72981 ms
Durée moyenne: 729.81 ms

Nœud v4.6.1 avec petit objet de 50 propriétés

testObjKeyWhileDecrement
Test Count: 1000
Temps Total: 8 ms
Durée moyenne: 0.008 ms

testObjKeyForLoop
Test Count: 1000
Temps Total: 10 ms
Durée moyenne: 0,01 ms

testForInLoop
Test Count: 1000
Temps Total: 13 ms
Durée moyenne: 0.013 ms

Et voici le code que j'ai couru:

//Helper functions
function work(value) {
//do some work on this value
}
function createTestObj(count) {
var obj = {}
while (count--) {
obj["key" + count] = "test";
}
return obj;
}
function runOnce(func, obj) {
var start = Date.now();
func(obj);
return Date.now() - start;
}
function testTimer(name, func, obj, count) {
count = count || 100;
var times = [];
var i = count;
var total;
var avg;
while (i--) {
times.push(runOnce(func, obj));
}
total = times.reduce(function (a, b) { return a + b });
avg = total / count;
console.log(name);
console.log('Test Count: ' + count);
console.log('Total Time: ' + total);
console.log('Average Time: ' + avg);
console.log('');
}
//Tests
function testObjKeyWhileDecrement(obj) {
var keys = Object.keys(obj);
var i = keys.length;
while (i--) {
work(obj[keys[i]]);
}
}
function testObjKeyForLoop(obj) {
var keys = Object.keys(obj);
var len = keys.length;
var i;
for (i = 0; i < len; i++) {
work(obj[keys[i]]);
}
}
function testForInLoop(obj) {
for (key in obj) {
if (obj.hasOwnProperty(key)) {
work(obj[key]);
}
}
}
//Run the Tests
var data = createTestObj(50)
testTimer('testObjKeyWhileDecrement', testObjKeyWhileDecrement, data, 1000);
testTimer('testObjKeyForLoop', testObjKeyForLoop, data, 1000);
testTimer('testForInLoop', testForInLoop, data, 1000);

Et pour l'ES6 fans, ressemble à

Object.keys(obj).reduce((a,k) => {a += obj[k]; return a}, res)

est de loin le plus rapide.

https://jsperf.com/for-in-vs-for-of-keys-vs-keys-reduce