Warum ist es eine schlechte Idee, "for...in" zur Iteration von Arrays zu verwenden?

Question

Man hat mir gesagt, for...in nicht mit Arrays in JavaScript zu verwenden. Warum nicht?

Answer 1

Sie sollten for(var x in y) nur auf Eigenschaftslisten und nicht auf Objekten verwenden (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 merkwürdige 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, würde deine Schleife am Ende viermal durchlaufen: key wäre 0, 1, 2 und helpfulUtilityMethod. Wenn du nur Ganzzahlen erwartet hast, Ups.

Answer 3

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

1.) Es gibt bereits eine High-Order-Funktion oder Methode, die den Zweck für ein Array erfüllt, jedoch mehr Funktionalität und schlankere Syntax hat, namens '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 Werte aus, die 'undefined' sind, sondern nur für die Indizes, die einen definierten Wert haben. Wenn du also nur einen Wert zuweist, wird diese Schleife die Funktion nur einmal ausführen, aber da ein Array aufgelistet ist, wird es immer eine Länge bis zum höchsten Index haben, der einen definierten Wert hat, jedoch könnte diese Länge beim Verwenden dieser Schleifen unbemerkt bleiben.

3.) Die Standard-For-Schleife führt eine Funktion so oft aus, 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 Wesentlichen kannst du jede Schleife verwenden, aber du solltest genau daran denken, wie sie funktionieren. Verstehe die Bedingungen, unter denen sich die verschiedenen Schleifen wiederholen, ihre separaten Funktionalitäten und erkenne, dass sie mehr oder weniger für unterschiedliche Szenarien geeignet sind.

Es kann auch als bessere Praxis angesehen werden, die forEach-Methode anstelle der for...in-Schleife im Allgemeinen zu verwenden, da sie einfacher zu schreiben ist und mehr Funktionalität bietet. Daher solltest du dich vielleicht daran gewöhnen, 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. Objekteigenschaftsschlüssel sind immer Strings, 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 mit einem Objekt in JavaScript arbeitet, aber nicht für ein Array, aber wir können trotzdem nicht sagen, dass es falsch ist, aber es wird nicht empfohlen. Schauen wir uns dieses Beispiel unten mit der for...in-Schleife an:

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, lassen Sie uns es 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 Sie sehen, ist das Ergebnis dasselbe...

Aber lasst uns etwas ausprobieren, lassen Sie uns etwas zum Array prototypen...

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

Sie sehen das someoneelse!!!... Wir durchlaufen tatsächlich das neue Array-Objekt in diesem Fall!

Daher ist das einer der Gründe, warum wir for..in vorsichtig verwenden müssen, aber das ist nicht immer der Fall...