Warum ist es keine gute Idee, "for...in" für die Iteration von Arrays zu verwenden?

Question

Ich wurde darauf hingewiesen, dass ich in JavaScript for...in nicht mit Arrays verwenden soll. Warum?

Answer 1

Sie sollten for(var x in y) nur auf Listen von Eigenschaften verwenden, nicht auf Objekten (wie oben erklärt).

Answer 2

Es ist nicht unbedingt schlecht (basierend auf dem, was du tust), aber im Fall von Arrays, wenn etwas zu Array.prototype hinzugefügt wurde, dann erhältst du seltsame Ergebnisse. Wo du erwarten würdest, dass diese Schleife dreimal durchläuft:

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

Wenn eine Funktion namens helpfulUtilityMethod zu Array's prototype hinzugefügt wurde, dann würde deine Schleife am Ende viermal durchlaufen werden: key wäre 0, 1, 2 und helpfulUtilityMethod. Wenn du nur ganze Zahlen erwartet hast, ups.

Answer 3

Die Verwendung der for...in-Schleife für ein Array ist nicht falsch, obwohl ich vermuten kann, warum dir jemand das gesagt hat:

1.) Es gibt bereits eine höhere Funktion oder Methode, die für ein Array diesen Zweck erfüllt, aber mehr Funktionalität und schlankere Syntax hat, genannt 'forEach': Array.prototype.forEach(function(element, index, array) {} );

2.) Arrays haben immer eine Länge, aber for...in und forEach führen keine Funktion für einen Wert aus, der 'undefined' ist, sondern nur für die Indizes, die einen definierten Wert haben. Wenn du also nur einen Wert zuweist, führen diese Schleifen die Funktion nur einmal aus, aber da ein Array aufgezählt wird, wird es immer eine Länge bis zum höchsten Index haben, der einen definierten Wert hat, aber diese Länge könnte unbemerkt bleiben, wenn du diese Schleifen benutzt.

3.) Die Standardschleife wird eine Funktion so oft ausführen, wie du es in den Parametern definierst, und da ein Array nummeriert ist, macht es mehr Sinn festzulegen, wie oft du eine Funktion ausführen möchtest. Im Gegensatz zu den anderen Schleifen kann die for-Schleife dann eine Funktion für jeden Index im Array ausführen, unabhängig davon, ob der Wert definiert ist oder nicht.

Im Grunde genommen kannst du jede Schleife verwenden, aber du solltest dich genau daran erinnern, wie sie funktionieren. Verstehe die Bedingungen, unter denen die verschiedenen Schleifen wiederholen, ihre unterschiedlichen Funktionalitäten und erkenne, dass sie mehr oder weniger geeignet für unterschiedliche Szenarien sein werden.

Es könnte auch als bessere Praxis angesehen werden, die Methode forEach anstelle der for...in-Schleife im Allgemeinen zu verwenden, da sie einfacher zu schreiben ist und mehr Funktionalität bietet. Du könntest also in die Gewohnheit kommen, nur diese Methode und die Standard for-Schleife zu verwenden, aber du entscheidest.

Sieh unten, dass die ersten beiden Schleifen die console.log-Anweisungen nur einmal ausführen, während die Standard for-Schleife die Funktion so oft ausführt wie angegeben, in diesem Fall array.length = 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]

Answer 4

Eine for...in-Schleife zählt immer die Schlüssel auf. Die Eigenschaftsschlüssel von Objekten sind immer String, auch die indizierten Eigenschaften eines Arrays :

var myArray = ['a', 'b', 'c', 'd'];
var total = 0
for (elem in myArray) {
  total += elem
}
console.log(total); // 00123

Answer 5

for...in ist nützlich, wenn man in JavaScript mit einem Objekt arbeitet, aber nicht für ein Array. Man kann jedoch nicht sagen, dass es falsch ist, aber es wird nicht empfohlen. Schau dir das folgende Beispiel an, in dem die for...in-Schleife verwendet wird:

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, lass es uns jetzt mit einem Array machen:

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

Wie du siehst, ist das Ergebnis das Gleiche...

Aber lass uns etwas ausprobieren, lass uns etwas zum Array hinzufügen...

Array.prototype.someoneelse = "someoneelse";

Jetzt erstellen wir ein neues Array();

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

Siehst du das someoneelse!!!... In diesem Fall durchlaufen wir tatsächlich das neue Array-Objekt!

Deshalb ist das einer der Gründe, warum man for..in vorsichtig verwenden sollte, aber das trifft nicht immer zu...