Diefor...in Anweisung iteriert über alleaufzählbaren Zeichenketteneigenschaften eines Objekts (ignoriert Eigenschaften, die durchSymbole gekennzeichnet sind), einschließlich geerbter aufzählbarer Eigenschaften.

Probieren Sie es aus

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"

Syntax

for (variable in object)  statement

Parameter

variable

Erhält auf jeder Iteration einen Zeichenkettenschlüssel. Kann entweder eine Deklaration mitconst,let odervar sein oder ein Ziel einerZuweisung (z.B. eine zuvor deklarierte Variable, eine Objekteigenschaft oder einDestrukturierungsmuster). Variablen, die mitvar deklariert sind, sind nicht lokal zur Schleife, d.h. sie befinden sich im selben Gültigkeitsbereich wie diefor...in Schleife.

object

Objekt, dessen aufzählbare Eigenschaften ohne Symbol durchlaufen werden.

statement

Eine Anweisung, die bei jedem Iterationsschritt ausgeführt wird. Kann sich aufvariable beziehen. Sie können eineBlockanweisung verwenden, um mehrere Anweisungen auszuführen.

Beschreibung

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 instatementKontrollflussanweisungen verwenden:

• break stoppt die Ausführung vonstatement und springt zur ersten Anweisung nach der Schleife.
• continue stoppt die Ausführung vonstatement und geht zur nächsten Iteration der Schleife über.

Einefor...in Schleife iteriert nur über aufzählbare Eigenschaften ohne Symbole. Von eingebauten Konstruktoren wieArray undObject erstellte Objekte haben nicht-auflistbare geerbte Eigenschaften vonArray.prototype undObject.prototype, wie dieArrayindexOf() Methode oder dieObjecttoString() Methode, die in derfor...in Schleife nicht besucht werden.

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.

Dervariable Teil vonfor...in akzeptiert alles, was vor dem= Operator stehen kann. Sie könnenconst 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 Sielet verwenden. Sie könnenDestrukturierung verwenden, um mehrere lokale Variablen zuzuweisen, oder einen Eigenschafts-Accesser wiefor (x.y in iterable), um den Wert einer Objekteigenschaft zuzuweisen. Jedoch sindusing undawait using nicht erlaubt, da die Variable immer eine Zeichenkette oder ein Symbol ist, während diese Deklarationen ein löschbares Objekt erfordern.

Eineveraltete Syntax erlaubtvar-Deklarationen der Schleifenvariablen mit einem Initialisator. Dies wirft einenSyntaxfehler im strengen Modus und wird im nicht-strengen Modus ignoriert.

Gelöschte, hinzugefügte oder geänderte Eigenschaften

for...in besucht Eigenschaften in folgender Weise:

1. Es erhält zuerst alle eigenen Zeichenkettenschlüssel des aktuellen Objekts, ähnlich wieObject.getOwnPropertyNames().
2. Für jeden Schlüssel, wenn keine Zeichenkette mit demselben Wert jemals besucht wurde, wird derEigenschaftsdeskriptor abgerufen und die Eigenschaft wird nur besucht, wenn sie aufzählbar ist. Diese Eigenschaftenzeichenkette wird jedoch als besucht markiert, selbst wenn sie nicht aufzählbar ist.
3. Dann wird das aktuelle Objekt durch sein Prototyp ersetzt und der Vorgang wird wiederholt.

Das bedeutet:

• Jede während der Iteration zum aktuell besuchten Objekt hinzugefügte Eigenschaft wird nicht besucht, da alle eigenen Eigenschaften des aktuellen Objekts vorher gespeichert wurden.
• Wenn mehrere Objekte in der Prototypenkette eine Eigenschaft mit demselben Namen haben, wird nur die erste berücksichtigt, und sie wird nur besucht, wenn sie aufzählbar ist. Wenn sie nicht aufzählbar ist, werden keine weiteren Eigenschaften mit demselben Namen weiter oben in der Prototypenkette besucht, auch wenn sie aufzählbar sind.

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:

• Die Prototypenkette des Objekts wird während der Iteration geändert.
• Eine Eigenschaft wird während der Iteration aus dem Objekt oder seiner Prototypenkette entfernt.
• Eine Eigenschaft wird während der Iteration in die Prototypenkette des Objekts hinzugefügt.
• Die Aufzählbarkeit einer Eigenschaft wird während der Iteration geändert.

In diesen Fällen können sich die Implementierungen anders verhalten, als Sie es erwarten, oder sogar voneinander abweichen.

Array-Iteration und for...in

Array-Indizes sind einfach aufzählbare Eigenschaften mit ganzzahligen Namen und ansonsten identisch mit allgemeinen Objekteigenschaften. Diefor...in Schleife wird alle ganzzahligen Schlüssel in streng aufsteigender Reihenfolge vor anderen Schlüsseln durchlaufen, wodurch das Verhalten vonfor...in der normalen Array-Iteration nahe kommt. However, diefor...in Schleife gibt alle aufzählbaren Eigenschaften zurück, einschließlich derjenigen mit nicht-ganzzahligen Namen und der geerbten Eigenschaften. Im Gegensatz zufor...of verwendetfor...in die Eigenschaftsaufzählung statt des Array-Iterators. Indünnbesetzten Arrays wirdfor...of die leeren Plätze besuchen,for...in jedoch nicht.

Es ist besser, einefor Schleife mit einem numerischen Index,Array.prototype.forEach(), oder diefor...of Schleife zu verwenden, da sie den Index als Zahl anstelle einer Zeichenkette zurückgeben und nicht-Index-Eigenschaften vermeiden.

Iteration nur über eigene Eigenschaften

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.getOwnPropertyNames()

Object.keys gibt eine Liste der aufzählbaren eigenen Zeichenketteneigenschaften zurück, währendObject.getOwnPropertyNames auch nicht-auflistbare Eigenschaften enthält.

Viele JavaScript-Stilhandbücher und Linter empfehlen, die Verwendung vonfor...in zu vermeiden, da es über die gesamte Prototypenkette iteriert, was selten gewünscht ist, und mit der weiter verbreitetenfor...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 mitfor...in überprüfen, ob einer dieser Schlüssel einen bestimmten Wert hält.

Beispiele

Verwendung von for...in

Die folgendefor...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"

Iteration über eigene Eigenschaften

Die folgende Funktion illustriert die Verwendung vonObject.hasOwn(): die geerbten Eigenschaften werden nicht angezeigt.

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"

Gleichzeitige Modifikation

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 = 2Object.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 visitedfor (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 visitedfor (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 });}

Spezifikationen

Browser-Kompatibilität

Siehe auch

• for...of
• for
• Aufzählbarkeit und Eigentümerschaft von Eigenschaften
• Object.getOwnPropertyNames()
• Object.hasOwn()
• Array.prototype.forEach()