HTML: Markup language
CSS: Styling language
JavaScript: Scripting language
Web APIs: Programming interfaces
All web technology
Learn web development
Discover our tools
Get to know MDN better
Dieser Inhalt wurde automatisch aus dem Englischen übersetzt, und kann Fehler enthalten. Erfahre mehr über dieses Experiment.
View in English Always switch to English
Diese Funktion ist gut etabliert und funktioniert auf vielen Geräten und in vielen Browserversionen. Sie ist seit Juli 2015 browserübergreifend verfügbar.
Die for...in Anweisung iteriert über alle aufzählbaren Zeichenketteneigenschaften eines Objekts (ignoriert Eigenschaften, die durch Symbole gekennzeichnet sind), einschließlich geerbter aufzählbarer Eigenschaften.
for...in
const object = { a: 1, b: 2, c: 3 }; for (const property in object) { console.log(`${property}: ${object[property]}`); } // Expected output: // "a: 1" // "b: 2" // "c: 3"
for (variable in object) statement
variable
Erhält auf jeder Iteration einen Zeichenkettenschlüssel. Kann entweder eine Deklaration mit const, let oder var sein oder ein Ziel einer Zuweisung (z.B. eine zuvor deklarierte Variable, eine Objekteigenschaft oder ein Destrukturierungsmuster). Variablen, die mit var deklariert sind, sind nicht lokal zur Schleife, d.h. sie befinden sich im selben Gültigkeitsbereich wie die for...in Schleife.
const
let
var
object
Objekt, dessen aufzählbare Eigenschaften ohne Symbol durchlaufen werden.
statement
Eine Anweisung, die bei jedem Iterationsschritt ausgeführt wird. Kann sich auf variable beziehen. Sie können eine Blockanweisung verwenden, um mehrere Anweisungen auszuführen.
Die Schleife iteriert über alle aufzählbaren Eigenschaften des Objekts selbst und über jene, die das Objekt von seiner Prototypenkette erbt (Eigenschaften näherer Prototypen haben Vorrang vor denen von Prototypen, die weiter vom Objekt entfernt sind).
Wie bei anderen Schleifenanweisungen können Sie in statement Kontrollflussanweisungen verwenden:
break
continue
Eine for...in Schleife iteriert nur über aufzählbare Eigenschaften ohne Symbole. Von eingebauten Konstruktoren wie Array und Object erstellte Objekte haben nicht-auflistbare geerbte Eigenschaften von Array.prototype und Object.prototype, wie die Array indexOf() Methode oder die Object toString() Methode, die in der for...in Schleife nicht besucht werden.
Array
Object
Array.prototype
Object.prototype
indexOf()
toString()
Die Durchlaufreihenfolge ist gemäß der modernen ECMAScript-Spezifikation gut definiert und konsistent über Implementierungen hinweg. Innerhalb jeder Komponente der Prototypenkette werden zuerst alle nicht-negativen ganzzahligen Schlüssel (die Array-Indizes sein können) in aufsteigender Reihenfolge nach Wert durchlaufen, dann andere Zeichenkettenschlüssel in aufsteigender chronologischer Reihenfolge der Eigenschaftenerstellung.
Der variable Teil von for...in akzeptiert alles, was vor dem = Operator stehen kann. Sie können const verwenden, um die Variable zu deklarieren, solange sie im Schleifenrumpf nicht neu zugewiesen wird (sie kann zwischen Iterationen wechseln, weil dies zwei separate Variablen sind). Andernfalls können Sie let verwenden. Sie können Destrukturierung verwenden, um mehrere lokale Variablen zuzuweisen, oder einen Eigenschafts-Accesser wie for (x.y in iterable), um den Wert einer Objekteigenschaft zuzuweisen. Jedoch sind using und await using nicht erlaubt, da die Variable immer eine Zeichenkette oder ein Symbol ist, während diese Deklarationen ein löschbares Objekt erfordern.
=
for (x.y in iterable)
using
await using
Eine veraltete Syntax erlaubt var-Deklarationen der Schleifenvariablen mit einem Initialisator. Dies wirft einen Syntaxfehler im strengen Modus und wird im nicht-strengen Modus ignoriert.
for...in besucht Eigenschaften in folgender Weise:
Object.getOwnPropertyNames()
Das bedeutet:
Im Allgemeinen ist es am besten, während der Iteration keine Eigenschaften des Objekts hinzuzufügen, zu ändern oder zu entfernen, außer der gerade besuchten Eigenschaft. Die Spezifikation erlaubt es explizit, dass die Implementierung dem Algorithmus in einem der folgenden Fälle nicht folgt:
In diesen Fällen können sich die Implementierungen anders verhalten, als Sie es erwarten, oder sogar voneinander abweichen.
Array-Indizes sind einfach aufzählbare Eigenschaften mit ganzzahligen Namen und ansonsten identisch mit allgemeinen Objekteigenschaften. Die for...in Schleife wird alle ganzzahligen Schlüssel in streng aufsteigender Reihenfolge vor anderen Schlüsseln durchlaufen, wodurch das Verhalten von for...in der normalen Array-Iteration nahe kommt. However, die for...in Schleife gibt alle aufzählbaren Eigenschaften zurück, einschließlich derjenigen mit nicht-ganzzahligen Namen und der geerbten Eigenschaften. Im Gegensatz zu for...of verwendet for...in die Eigenschaftsaufzählung statt des Array-Iterators. In dünnbesetzten Arrays wird for...of die leeren Plätze besuchen, for...in jedoch nicht.
for...of
Es ist besser, eine for Schleife mit einem numerischen Index, Array.prototype.forEach(), oder die for...of Schleife zu verwenden, da sie den Index als Zahl anstelle einer Zeichenkette zurückgeben und nicht-Index-Eigenschaften vermeiden.
for
Array.prototype.forEach()
Wenn Sie nur die zum Objekt selbst gehörenden Eigenschaften, nicht aber die seiner Prototypen berücksichtigen möchten, können Sie eine der folgenden Techniken verwenden:
Object.keys()
Object.keys gibt eine Liste der aufzählbaren eigenen Zeichenketteneigenschaften zurück, während Object.getOwnPropertyNames auch nicht-auflistbare Eigenschaften enthält.
Object.keys
Object.getOwnPropertyNames
Viele JavaScript-Stilhandbücher und Linter empfehlen, die Verwendung von for...in zu vermeiden, da es über die gesamte Prototypenkette iteriert, was selten gewünscht ist, und mit der weiter verbreiteten for...of Schleife verwechselt werden könnte. for...in wird am praktischsten für Debugging-Zwecke verwendet, da es eine einfache Möglichkeit bietet, die Eigenschaften eines Objekts zu überprüfen (indem sie in die Konsole ausgegeben werden oder auf andere Weise). In Situationen, in denen Objekte als Ad-hoc-Schlüssel-Wert-Paare verwendet werden, können Sie mit for...in überprüfen, ob einer dieser Schlüssel einen bestimmten Wert hält.
Die folgende for...in Schleife iteriert über alle aufzählbaren Eigenschaften eines Objekts ohne Symbole und protokolliert eine Zeichenkette der Eigenschaftsnamen und ihrer Werte.
const obj = { a: 1, b: 2, c: 3 }; for (const prop in obj) { console.log(`obj.${prop} = ${obj[prop]}`); } // Logs: // "obj.a = 1" // "obj.b = 2" // "obj.c = 3"
Die folgende Funktion illustriert die Verwendung von Object.hasOwn(): die geerbten Eigenschaften werden nicht angezeigt.
Object.hasOwn()
const triangle = { a: 1, b: 2, c: 3 }; function ColoredTriangle() { this.color = "red"; } ColoredTriangle.prototype = triangle; const obj = new ColoredTriangle(); for (const prop in obj) { if (Object.hasOwn(obj, prop)) { console.log(`obj.${prop} = ${obj[prop]}`); } } // Logs: // "obj.color = red"
Warnung: Sie sollten diesen Code nicht selbst schreiben. Er ist hier nur enthalten, um das Verhalten von for...in in einigen Grenzfällen zu veranschaulichen.
Eigenschaften, die während der Iteration zum aktuellen Objekt hinzugefügt werden, werden nie besucht:
const obj = { a: 1, b: 2 }; for (const prop in obj) { console.log(`obj.${prop} = ${obj[prop]}`); obj.c = 3; } // Logs: // obj.a = 1 // obj.b = 2
Überschattete Eigenschaften werden nur einmal besucht:
const proto = { a: 1 }; const obj = { __proto__: proto, a: 2 }; for (const prop in obj) { console.log(`obj.${prop} = ${obj[prop]}`); } // Logs: // obj.a = 2 Object.defineProperty(obj, "a", { enumerable: false }); for (const prop in obj) { console.log(`obj.${prop} = ${obj[prop]}`); } // Logs nothing, because the first "a" property visited is non-enumerable.
Darüber hinaus berücksichtigen Sie die folgenden Fälle, in denen das Verhalten nicht spezifiziert ist und die Implementierungen dazu neigen, von dem spezifizierten Algorithmus abzuweichen:
Ändern des Prototyps während der Iteration:
const obj = { a: 1, b: 2 }; for (const prop in obj) { console.log(`obj.${prop} = ${obj[prop]}`); Object.setPrototypeOf(obj, { c: 3 }); }
Löschen einer Eigenschaft während der Iteration:
const obj = { a: 1, b: 2, c: 3 }; // Deleting a property before it is visited for (const prop in obj) { console.log(`obj.${prop} = ${obj[prop]}`); delete obj.c; } const obj2 = { a: 1, b: 2, c: 3 }; // Deleting a property after it is visited for (const prop in obj2) { console.log(`obj2.${prop} = ${obj2[prop]}`); delete obj2.a; }
Aufzählbare Eigenschaften, die während der Iteration zum Prototyp hinzugefügt werden:
const proto = {}; const obj = { __proto__: proto, a: 1, b: 2 }; for (const prop in obj) { console.log(`obj.${prop} = ${obj[prop]}`); proto.c = 3; }
Ändern der Aufzählbarkeit einer Eigenschaft während der Iteration:
const obj = { a: 1, b: 2, c: 3 }; for (const prop in obj) { console.log(`obj.${prop} = ${obj[prop]}`); Object.defineProperty(obj, "c", { enumerable: false }); }
JavaScript aktivieren, um diese Browser-Kompatibilitätstabelle anzuzeigen.