Pourquoi utiliser "pour..." avec la matrice d'itération une mauvaise idée?

on m'a dit de ne pas utiliser for...in avec des tableaux en JavaScript. Pourquoi pas?

1575
demandé sur John Slegers 2009-02-01 12:46:38
la source

25 ответов

la raison est qu'une construction:

var a = []; // Create a new empty array.
a[5] = 5;   // Perfectly legal JavaScript that resizes the array.

for (var i = 0; i < a.length; i++) {
    // Iterate over numeric indexes from 0 to 5, as everyone expects.
    console.log(a[i]);
}

/* Will display:
   undefined
   undefined
   undefined
   undefined
   undefined
   5
*/

peut parfois être totalement différent de l'autre:

var a = [];
a[5] = 5;
for (var x in a) {
    // Shows only the explicitly set index of "5", and ignores 0-4
    console.log(x);
}

/* Will display:
   5
*/

aussi considérer que JavaScript les bibliothèques pourraient faire des choses comme ceci, qui affectera n'importe quel tableau que vous créez:

// Somewhere deep in your JavaScript library...
Array.prototype.foo = 1;

// Now you have no idea what the below code will do.
var a = [1, 2, 3, 4, 5];
for (var x in a){
    // Now foo is a part of EVERY array and 
    // will show up here as a value of 'x'.
    console.log(x);
}

/* Will display:
   0
   1
   2
   3
   4
   foo
*/
1374
répondu Triptych 2017-10-09 10:51:46
la source

la déclaration for-in en elle-même n'est pas une "mauvaise pratique", mais elle peut être mal utilisée , par exemple, à itérer sur des tableaux ou des objets semblables à des tableaux.

le but de l'énoncé for-in est de énumérer sur les propriétés de l'objet. Cette déclaration va monter dans la chaîne prototype, en énumérant également plus de héritées propriétés, une chose qui parfois n'est pas désiré.

Aussi, l'ordre d'itération n'est pas garanti par la spécification., ce qui signifie que si vous voulez "itérer" un objet de tableau, avec cette instruction vous ne pouvez pas être sûr que les propriétés (index de tableau) seront visitées dans l'ordre numérique.

par exemple, dans JScript (IE <= 8), l'ordre d'énumération même sur les objets Array est défini comme les propriétés ont été créées:

var array = [];
array[2] = 'c';
array[1] = 'b';
array[0] = 'a';

for (var p in array) {
  //... p will be "2", "1" and "0" on IE
}

aussi, en parlant des propriétés héritées, si vous, par exemple, étendez l'objet Array.prototype (comme certaines bibliothèques comme MooTools), que les propriétés seront également énumérées:

Array.prototype.last = function () { return this[this.length-1]; };

for (var p in []) { // an empty array
  // last will be enumerated
}

comme je l'ai déjà dit à iterate sur les tableaux ou les objets de type tableau, la meilleure chose est d'utiliser une boucle séquentielle , telle qu'une simple for / while boucle.

Quand vous voulez énumérer seulement le propres propriétés d'un objet( ceux qui ne sont pas hérités), vous pouvez utiliser la hasOwnProperty méthode:

for (var prop in obj) {
  if (obj.hasOwnProperty(prop)) {
    // prop is not inherited
  }
}

et certaines personnes recommandent même d'appeler la méthode directement de Object.prototype pour éviter d'avoir des problèmes si quelqu'un ajoute une propriété appelée hasOwnProperty à notre objet:

for (var prop in obj) {
  if (Object.prototype.hasOwnProperty.call(obj, prop)) {
    // prop is not inherited
  }
}
359
répondu CMS 2016-02-24 20:51:32
la source

il y a trois raisons pour lesquelles vous ne devriez pas utiliser for..in pour itérer des éléments de tableau:

  • for..in boucle toutes les propriétés propres et héritées de l'objet array qui ne sont pas DontEnum ; cela signifie que si quelqu'un ajoute des propriétés à l'objet array spécifique (il ya des raisons valables pour cela - je l'ai fait moi-même) ou changé Array.prototype (qui est considéré comme une mauvaise pratique dans le code qui est censé bien fonctionner avec Autres scripts), ces propriétés seront itérées aussi bien; les propriétés héritées peuvent être exclues en cochant hasOwnProperty() , mais cela ne vous aidera pas avec les propriétés définies dans l'objet array lui-même

  • for..in n'est pas garanti pour préserver l'élément de commande

  • c'est lent parce qu'il faut parcourir toutes les propriétés de l'objet array et de toute sa chaîne prototype et n'obtiendra toujours que le nom de la propriété, c'est-à-dire pour obtenir la valeur, une recherche supplémentaire sera nécessaire

101
répondu Christoph 2009-02-01 17:16:38
la source

parce que for ... in énumère à travers l'objet qui tient le tableau, pas le tableau lui-même. Si j'ajoute une fonction à la chaîne prototype arrays, cela sera également inclus. C'est-à-dire:

Array.prototype.myOwnFunction = function() { alert(this); }
a = new Array();
a[0] = 'foo';
a[1] = 'bar';
for(x in a){
 document.write(x + ' = ' + a[x]);
}

ceci écrira:

0 = foo
1 = bar
myOwnFunction = function() { alert(this); }

et comme vous ne pouvez jamais être sûr que rien ne sera ajouté à la chaîne prototype utilisez simplement une boucle for pour énumérer le tableau:

for(i=0,x=a.length;i<x;i++){
 document.write(i + ' = ' + a[i]);
}

ceci écrira:

0 = foo
1 = bar
49
répondu Pim Jager 2016-11-14 16:41:06
la source

dans l'isolement, il n'y a rien de mal à utiliser for-in sur les tableaux. For-in itère les noms de propriétés d'un objet, et dans le cas d'un tableau "out-of-the-box", les propriétés correspondent aux index du tableau. (Les propriétés intégrées comme length , toString et ainsi de suite ne sont pas incluses dans l'itération.)

cependant, si votre code (ou le framework que vous utilisez) ajoute des propriétés personnalisées aux tableaux ou au prototype de tableau, alors ces propriétés seront inclus dans l'itération, ce qui n'est probablement pas ce que vous voulez.

certains cadres JS, comme Prototype modifie le prototype du réseau. D'autres cadres comme JQuery ne le font pas, donc avec JQuery vous pouvez utiliser en toute sécurité for-in.

Si vous êtes dans le doute, vous ne devriez pas l'utiliser pour.

une autre façon d'itérer à travers un tableau est d'utiliser une boucle:

for (var ix=0;ix<arr.length;ix++) alert(ix);

cependant, cela ont un autre question. Le problème est qu'un tableau JavaScript peut avoir des "trous". Si vous définissez arr comme:

var arr = ["hello"];
arr[100] = "goodbye";

puis le tableau ont deux éléments, mais une longueur de 101. L'utilisation de for-in donnera deux indices, tandis que la boucle for donnera 101 indices, où le 99 a une valeur de undefined .

37
répondu JacquesB 2014-10-24 01:28:25
la source

en plus des raisons données dans d'autres réponses, vous pouvez ne pas vouloir utiliser la structure" for...in " Si vous avez besoin de faire des maths avec la variable counter parce que la boucle itère à travers les noms des propriétés de l'objet et donc la variable est une chaîne.

par exemple,

for (var i=0; i<a.length; i++) {
    document.write(i + ', ' + typeof i + ', ' + i+1);
}

écrira

0, number, 1
1, number, 2
...

attendu que,

for (var ii in a) {
    document.write(i + ', ' + typeof i + ', ' + i+1);
}

écrira

0, string, 01
1, string, 11
...

bien sûr, cela peut facilement être surmonté en incluant

ii = parseInt(ii);

dans la boucle, mais la première structure est plus directe.

29
répondu ctmiddle 2009-09-02 06:29:46
la source

à partir de 2016 (ES6) nous pouvons utiliser for…of pour l'itération des réseaux, comme John Slegers l'a déjà remarqué.

je voudrais juste ajouter ce code de démonstration simple, pour rendre les choses plus claires:

Array.prototype.foo = 1;
var arr = [];
arr[5] = "xyz";

console.log("for...of:");
var count = 0;
for (var item of arr) {
    console.log(count + ":", item);
    count++;
    }

console.log("for...in:");
count = 0;
for (var item in arr) {
    console.log(count + ":", item);
    count++;
    }

la console affiche:

for...of:

0: undefined
1: undefined
2: undefined
3: undefined
4: undefined
5: xyz

for...in:

0: 5
1: foo

en d'autres termes:

  • for...of compte de 0 à 5, et ignore aussi Array.prototype.foo . Il affiche les valeurs du tableau .

  • for...in liste seulement le 5 , ignorant les index de tableaux non définis, mais ajoutant foo . Il montre le tableau les noms de propriété .

26
répondu MarcG 2016-03-10 07:29:37
la source

mis à part le fait que for ... in passe en boucle sur toutes les propriétés énumérables (qui est pas la même chose que "tous les éléments du tableau"!), voir . http://www.ecma-international.org/publications/files/ECMA-ST/Ecma-262.pdf , section 12.6.4 (5e édition) ou 13.7.5.15 (7e édition):

de La mécanique et de ordre de l'énumération des propriétés ... n'est pas spécifié ...

(l'Emphase est mienne.)

cela signifie que si un navigateur voulait, il pourrait passer par les propriétés dans l'ordre dans lequel elles ont été insérées. Ou dans l'ordre numérique. Ou dans l'ordre lexical (où "30" vient avant "4"! Gardez à l'esprit que toutes les clés d'objets -- et donc tous les index de tableaux -- sont en fait des chaînes, donc cela a un sens total). Il pourrait passer par eux par seau, si elle a mis en œuvre des objets comme des tables de hachage. Ou prenez tout ça et ajoutez "à l'envers". Un navigateur pourrait même itérer au hasard et être conforme ECMA-262, tant qu'il a visité chaque propriété exactement une fois.

dans la pratique, la plupart des navigateurs aiment actuellement itérer dans le même ordre. Mais il n'y a rien en disant qu'ils ont à faire. C'est la mise en œuvre spécifique, et pourrait changer à tout moment si un autre moyen était trouvé pour être beaucoup plus efficace.

de toute façon, for ... in n'a pas de connotation d'ordre. Si vous vous souciez de l'ordre, soyez explicite à ce sujet et utilisez une boucle régulière for avec un index.

21
répondu cHao 2016-07-28 11:55:07
la source

brève réponse: ça n'en vaut pas la peine.


réponse plus longue: cela n'en vaut pas la peine, même si l'ordre séquentiel des éléments et les performances optimales ne sont pas nécessaires.


longue réponse: il est tout simplement pas la peine, pour les raisons suivantes:

  • L'utilisation de for (var i in array) {} fera que "array" sera interprété comme n'importe quel autre pur objet, traversant la la chaîne de propriété de l'objet et finalement plus lente qu'une boucle for basée sur un index.
  • il n'est pas garanti de rendre les propriétés de l'objet dans l'ordre séquentiel comme on pourrait s'y attendre.
  • en utilisant hasOwnProperty() ou isNaN() pour filtrer les propriétés de l'objet est un overhead supplémentaire qui le fait effectuer (encore plus) plus lent. Aussi, l'introduction d'une telle logique supplémentaire nie la raison principale de l'aide en premier lieu, c'est à dire parce que du format plus concis.

pour ces raisons, il n'existe même pas de compromis acceptable entre la performance et la commodité. En réalité, il n'y a aucun avantage à moins que l'intention soit de traiter le tableau comme un objet pur et effectue des opérations sur les propriétés de l'objet tableau.

20
répondu WynandB 2013-07-04 04:20:42
la source

parce qu'il énumère à travers des champs d'objets, pas des index. Vous pouvez obtenir la valeur à l'index "longueur" et je doute que vous souhaitez.

15
répondu vava 2009-02-01 12:50:03
la source

principalement deux raisons:

Un

comme d'autres l'ont dit, vous pourriez obtenir des clés qui ne sont pas dans votre tableau ou qui sont héritées du prototype. Si, par exemple, une bibliothèque ajoute une propriété au tableau ou aux prototypes D'objets:

Array.prototype.someProperty = true

vous l'obtiendrez comme partie de chaque tableau:

for(var item in [1,2,3]){
  console.log(item) // will log 1,2,3 but also "someProperty"
}

vous pourriez résoudre cela avec la méthode hasOwnProperty:

var ary = [1,2,3];
for(var item in ary){
   if(ary.hasOwnProperty(item)){
      console.log(item) // will log only 1,2,3
   }
}

mais ceci est vrai pour itérer sur n'importe quel objet avec une boucle for-in.

deux

habituellement, l'ordre des éléments dans un tableau est important, mais la boucle for-in ne sera pas nécessairement itérée dans le bon ordre, c'est parce qu'elle traite le tableau comme un objet, ce qui est la façon dont il est mis en œuvre dans JS, et pas comme un tableau. Cela semble une petite chose, mais il peut vraiment foirer les applications et est difficile à débogage.

15
répondu Lior 2014-02-04 20:54:16
la source

le problème avec for ... in ... - et cela ne devient un problème que lorsqu'un programmeur ne comprend pas vraiment le langage; ce n'est pas vraiment un bug ou quoi que ce soit - est qu'il itère sur tous les membres d'un objet (bien, tous énumérables les membres, mais c'est un détail pour le moment). Lorsque vous voulez itérer plus juste les propriétés indexées d'un tableau, la seule façon garantie de garder les choses sémantiquement cohérente est d'utiliser un index entier (c'est un for (var i = 0; i < array.length; ++i) style de boucle).

tout objet peut avoir des propriétés arbitraires qui lui sont associées. Il n'y aurait rien de terrible à charger des propriétés supplémentaires sur une instance de tableau, en particulier. Le Code qui veut voir seulement les propriétés de type tableau indexé donc doit coller à un index entier. Code qui est pleinement conscient de ce que for ... in fait et vraiment besoin pour voir toutes les propriétés, alors c'est ok aussi.

14
répondu Pointy 2015-03-06 16:26:19
la source

je ne pense pas avoir grand chose à rajouter par exemple. réponse de Triptyque ou réponse DE CMS sur pourquoi l'utilisation de for-in devrait être évitée dans certains cas.

je voudrais cependant ajouter que dans les navigateurs modernes il existe une alternative à for-in qui peut être utilisée dans les cas où for-in ne peut pas être utilisé. Cette alternative est for-of :

for (var item of items) {
    console.log(item);
}

Note:

malheureusement, aucune version D'Internet Explorer ne supporte cette fonctionnalité ( Edge 12+ does), donc vous devrez attendre un peu plus longtemps jusqu'à ce que vous puissiez l'utiliser dans votre code de production côté client. Cependant, il doit être sûr à utiliser dans votre code JS côté serveur (si vous utilisez noeud.js ).

10
répondu John Slegers 2018-03-08 11:55:53
la source

aussi, en raison de la sémantique, la façon dont for, in traite les tableaux (c.-à-d. le même que tout autre objet JavaScript) n'est pas aligné avec d'autres langues populaires.

// C#
char[] a = new char[] {'A', 'B', 'C'};
foreach (char x in a) System.Console.Write(x); //Output: "ABC"

// Java
char[] a = {'A', 'B', 'C'};
for (char x : a) System.out.print(x);          //Output: "ABC"

// PHP
$a = array('A', 'B', 'C');
foreach ($a as $x) echo $x;                    //Output: "ABC"

// JavaScript
var a = ['A', 'B', 'C'];
for (var x in a) document.write(x);            //Output: "012"
8
répondu matpop 2013-10-25 20:43:32
la source

en plus des autres problèmes, la syntaxe" for..in " est probablement plus lente, parce que l'index est une chaîne, pas un entier.

var a = ["a"]
for (var i in a)
    alert(typeof i)  // 'string'
for (var i = 0; i < a.length; i++)
    alert(typeof i)  // 'number'
7
répondu dc1 2012-06-06 02:59:12
la source

un aspect important est que for...in itère seulement sur les propriétés contenues dans un objet qui ont leur énumérable attribut de propriété mis à true. Ainsi, si l'on tente d'itérer un objet en utilisant for...in , les propriétés arbitraires peuvent être manquées si leur attribut de propriété énumérable est faux. Il est tout à fait possible de modifier l'attribut de propriété énumérable pour les objets de tableau normaux de sorte que certains éléments ne sont pas énumérés. Bien qu'en général les attributs de propriété ont tendance à s'appliquer aux propriétés de fonction dans un objet.

on peut vérifier la valeur d'un attribut de propriété énumérable d'une propriété par:

myobject.propertyIsEnumerable('myproperty')

ou pour obtenir les quatre attributs de propriété:

Object.getOwnPropertyDescriptor(myobject,'myproperty')

c'est une fonctionnalité disponible dans ECMAScript 5 - dans les versions précédentes, il n'était pas possible de modifier la valeur de l'attribut de propriété énumérable (il était toujours à vrai).

7
répondu Pierz 2013-05-10 22:20:26
la source

le for / in fonctionne avec deux types de variables: hashtables (associative arrays) et array (non-associative).

JavaScript va automatiquement déterminer la façon dont il passe à travers les articles. Donc, si vous savez que votre tableau est vraiment non-associatif , vous pouvez utiliser for (var i=0; i<=arrayLen; i++) , et sauter l'itération d'auto-détection.

mais à mon avis, il est préférable d'utiliser for / in , le processus requis pour que auto-détection est très faible.

une vraie réponse à cette question dépendra de la façon dont le navigateur interprète/interprète le code JavaScript. Il peut changer entre les navigateurs.

Je ne peux pas penser à d'autres buts à ne pas utiliser for / in ;

//Non-associative
var arr = ['a', 'b', 'c'];
for (var i in arr)
   alert(arr[i]);

//Associative
var arr = {
   item1 : 'a',
   item2 : 'b',
   item3 : 'c'
};

for (var i in arr)
   alert(arr[i]);
7
répondu Ricardo 2013-07-13 05:15:24
la source

TL&DR: utiliser la boucle for in dans les tableaux n'est pas mauvais, en fait tout à fait le contraire.

je pense que la boucle for in est un bijou de JS si utilisé correctement dans les tableaux. Vous êtes censé avoir le contrôle total sur votre logiciel et savoir ce que vous faites. Voyons les inconvénients mentionnés et à réfuter un par un.

  1. Il parcourt hérité propriétés aussi bien: tout D'abord toutes les extensions du Array.prototype auraient dû être faites en utilisant Object.defineProperty() et leur descripteur enumerable devrait être réglé à false . Toute bibliothèque qui ne le fait pas ne devrait pas être utilisée du tout.
  2. propriétés ceux que vous ajoutez à la chaîne de transmission plus tard sont comptés: en faisant la sous-classe de tableau par Object.setPrototypeOf ou par Classe extend . Vous devriez utiliser Object.defineProperty() qui définit par défaut les descripteurs de propriété writable , enumerable et configurable à false . Permet de voir un exemple de sous-classe de tableau ici...

function Stack(...a){
  var stack = new Array(...a);
  Object.setPrototypeOf(stack, Stack.prototype);
  return stack;
}
Stack.prototype = Object.create(Array.prototype);                                 // now stack has full access to array methods.
Object.defineProperty(Stack.prototype,"constructor",{value:Stack});               // now Stack is a proper constructor
Object.defineProperty(Stack.prototype,"peak",{value: function(){                  // add Stack "only" methods to the Stack.prototype.
                                                       return this[this.length-1];
                                                     }
                                             });
var s = new Stack(1,2,3,4,1);
console.log(s.peak());
s[s.length] = 7;
console.log("length:",s.length);
s.push(42);
console.log(JSON.stringify(s));
console.log("length:",s.length);

for(var i in s) console.log(s[i]);

comme vous voyez.. La boucle for in est maintenant sécurisée puisque vous vous souciez de votre code.

  1. la boucle for in est lente: Hell no. C'est de loin la méthode d'itération la plus rapide. si vous êtes en boucle sur matrices creuses qui sont nécessaires de temps en temps. C'est l'un des trucs de performance les plus importants que l'on devrait connaître. Voyons un exemple. Nous ferons une boucle sur un réseau épars.

var a = [];
a[0] = "zero";
a[10000000] = "ten million";
console.time("for loop on array a:");
for(var i=0; i < a.length; i++) a[i] && console.log(a[i]);
console.timeEnd("for loop on array a:");
console.time("for in loop on array a:");
for(var i in a) a[i] && console.log(a[i]);
console.timeEnd("for in loop on array a:");
7
répondu Redu 2017-01-28 11:16:02
la source

parce qu'il va itérer sur les propriétés appartenant aux objets en haut de la chaîne prototype si vous n'êtes pas prudent.

vous pouvez utiliser for.. in , assurez-vous de vérifier chaque propriété avec hasOwnProperty .

6
répondu JAL 2010-11-24 00:20:54
la source

ce n'est pas nécessairement mauvais (basé sur ce que vous faites), mais dans le cas des tableaux, si quelque chose a été ajouté à Array.prototype , alors vous allez obtenir des résultats étranges. Où l'on s'attend à ce que cette boucle tourne trois fois:

var arr = ['a','b','c'];
for (var key in arr) { ... }

si une fonction appelée helpfulUtilityMethod a été ajoutée à Array 's prototype , alors votre boucle finirait par courir quatre fois: key serait 0 , 1 , 2 , et helpfulUtilityMethod . Si tu t'attendais à des entiers, Oups.

5
répondu josh3736 2010-11-24 00:25:07
la source

vous devez utiliser le for(var x in y) seulement sur les listes de propriétés, pas sur les objets (comme expliqué ci-dessus).

5
répondu user268396 2010-11-24 00:25:10
la source

utiliser la boucle for...in pour un tableau n'est pas mal, Bien que je puisse deviner pourquoi quelqu'un vous a dit que:

1.) Il y a déjà une fonction d'ordre supérieur, ou une méthode, qui a ce but pour un tableau, mais a plus de fonctionnalité et une syntaxe plus allégée, appelée 'forEach': Array.prototype.forEach(function(element, index, array) {} );

2.) Les tableaux ont toujours une longueur, mais for...in et forEach n'exécutent pas de fonction pour n'importe quelle valeur qui est 'undefined' , seulement pour les index qui ont une valeur définie. Donc si vous assignez seulement une valeur, ces boucles n'exécuteront une fonction qu'une seule fois, mais puisqu'un tableau est énuméré, il aura toujours une longueur jusqu'à l'index le plus élevé qui a une valeur définie, mais cette longueur pourrait passer inaperçue en utilisant ces boucles.

3.), La norme pour la boucle pour exécuter une fonction autant de fois que vous définissez dans les paramètres, et depuis un tableau est numéroté, il est plus logique de définir combien de fois vous voulez exécuter une fonction. Contrairement aux autres boucles, la boucle for peut alors exécuter une fonction pour chaque indice dans le tableau, que la valeur soit définie ou non.

En essence, vous pouvez utiliser une boucle, mais vous devriez vous rappeler exactement comment ils fonctionnent. Comprendre les conditions dans lesquelles les différentes boucles se répètent, leurs fonctionnalités distinctes, et se rendre compte qu'elles seront plus ou moins appropriées à des scénarios différents.

aussi, il peut être considéré comme un meilleur pratiquez d'utiliser la méthode forEach plutôt que la boucle for...in en général, parce qu'elle est plus facile à écrire et a plus de fonctionnalités, donc vous pouvez vouloir prendre l'habitude d'utiliser seulement cette méthode et standard pour, mais votre appel.

voir ci-dessous que les deux premières boucles n'exécutent que la console.enregistrez les instructions une fois, tandis que le standard pour loop exécute la fonction autant de fois que spécifié, dans ce cas, array.longueur = 6.

var arr = [];
arr[5] = 'F';

for (var index in arr) {
console.log(index);
console.log(arr[index]);
console.log(arr)
}
// 5
// 'F'
// => (6) [undefined x 5, 6]

arr.forEach(function(element, index, arr) {
console.log(index);
console.log(element);
console.log(arr);
});
// 5
// 'F'
// => Array (6) [undefined x 5, 6]

for (var index = 0; index < arr.length; index++) {
console.log(index);
console.log(arr[index]);
console.log(arr);
};
// 0
// undefined
// => Array (6) [undefined x 5, 6]

// 1
// undefined
// => Array (6) [undefined x 5, 6]

// 2
// undefined
// => Array (6) [undefined x 5, 6]

// 3
// undefined
// => Array (6) [undefined x 5, 6]

// 4
// undefined
// => Array (6) [undefined x 5, 6]

// 5
// 'F'
// => Array (6) [undefined x 5, 6]
3
répondu mrmaclean89 2017-10-24 15:18:48
la source

pour... est utile lorsque vous travaillez sur un objet en JavaScript, mais pas pour un Tableau, mais on ne peut pas dire que c'est une mauvaise façon, mais il n'est pas recommandé, regardez cet exemple ci-dessous à l'aide de pour... en boucle:

let txt = "";
const person = {fname:"Alireza", lname:"Dezfoolian", age:35}; 
for (const x in person) {
    txt += person[x] + " ";
}
console.log(txt); //Alireza Dezfoolian 35 

OK, faisons-le avec Array maintenant:

let txt = "";
const person = ["Alireza", "Dezfoolian", 35]; 
for (const x in person) {
   txt += person[x] + " ";
}
console.log(txt); //Alireza Dezfoolian 35 

comme vous voyez le résultat le même...

mais essayons quelque chose, essayons prototype quelque chose à Array ...

Array.prototype.someoneelse = "someoneelse";

maintenant nous créons un nouveau tableau ();

let txt = "";
const arr = new Array();
arr[0] = 'Alireza';
arr[1] = 'Dezfoolian';
arr[2] = 35;
for(x in arr) {
 txt += arr[x] + " ";
}
console.log(txt); //Alireza Dezfoolian 35 someoneelse

vous voyez le someoneelse !!!... Nous sommes en fait en boucle à travers un nouvel objet Array dans ce cas!

donc c'est l'une des raisons pour lesquelles nous devons utiliser pour..dans soigneusement, mais ce n'est pas toujours le cas...

1
répondu Alireza 2017-12-25 16:38:50
la source

comme les éléments JavaScript sont enregistrés en tant que propriétés d'objet standard, il N'est pas conseillé d'itérer par des tableaux JavaScript en utilisant pour ... en boucles normal éléments et toutes les propriétés énumérables énuméré.

de https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Indexed_collections

0
répondu Badr Elmers 2018-01-14 04:23:48
la source

...en boucle toujours énumère les touches. Les clés de propriétés des objets sont toujours String, même les propriétés indexées d'un tableau:

var myArray = ['a', 'b', 'c', 'd'];
var total = 0
for (elem in myArray) {
  total += elem
}
console.log(total); // 00123
0
répondu Maher Tliba 2018-05-04 19:10:34
la source

Autres questions sur javascript arrays for-loop loops iteration