for...in

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

Erhlt auf jeder Iteration einen Zeichenkettenschlssel. 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 Gltigkeitsbereich wie die for...in Schleife.

object

Objekt, dessen aufzhlbare Eigenschaften ohne Symbol durchlaufen werden.

statement

Eine Anweisung, die bei jedem Iterationsschritt ausgefhrt wird. Kann sich auf variable beziehen. Sie knnen eine Blockanweisung verwenden, um mehrere Anweisungen auszufhren.

Beschreibung

Die Schleife iteriert ber alle aufzhlbaren Eigenschaften des Objekts selbst und ber jene, die das Objekt von seiner Prototypenkette erbt (Eigenschaften nherer Prototypen haben Vorrang vor denen von Prototypen, die weiter vom Objekt entfernt sind).

Wie bei anderen Schleifenanweisungen knnen Sie in statement Kontrollflussanweisungen verwenden:

• break stoppt die Ausfhrung von statement und springt zur ersten Anweisung nach der Schleife.
• continue stoppt die Ausfhrung von statement und geht zur nchsten Iteration der Schleife ber.

Eine for...in Schleife iteriert nur ber aufzhlbare 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.

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 Schlssel (die Array-Indizes sein knnen) in aufsteigender Reihenfolge nach Wert durchlaufen, dann andere Zeichenkettenschlssel in aufsteigender chronologischer Reihenfolge der Eigenschaftenerstellung.

Der variable Teil von for...in akzeptiert alles, was vor dem = Operator stehen kann. Sie knnen 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 knnen Sie let verwenden. Sie knnen 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, whrend diese Deklarationen ein lschbares Objekt erfordern.

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.

Gelschte, hinzugefgte oder genderte Eigenschaften

for...in besucht Eigenschaften in folgender Weise:

1. Es erhlt zuerst alle eigenen Zeichenkettenschlssel des aktuellen Objekts, hnlich wie Object.getOwnPropertyNames().
2. Fr jeden Schlssel, wenn keine Zeichenkette mit demselben Wert jemals besucht wurde, wird der Eigenschaftsdeskriptor abgerufen und die Eigenschaft wird nur besucht, wenn sie aufzhlbar ist. Diese Eigenschaftenzeichenkette wird jedoch als besucht markiert, selbst wenn sie nicht aufzhlbar ist.
3. Dann wird das aktuelle Objekt durch sein Prototyp ersetzt und der Vorgang wird wiederholt.

Das bedeutet:

• Jede whrend der Iteration zum aktuell besuchten Objekt hinzugefgte 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 bercksichtigt, und sie wird nur besucht, wenn sie aufzhlbar ist. Wenn sie nicht aufzhlbar ist, werden keine weiteren Eigenschaften mit demselben Namen weiter oben in der Prototypenkette besucht, auch wenn sie aufzhlbar sind.

Im Allgemeinen ist es am besten, whrend der Iteration keine Eigenschaften des Objekts hinzuzufgen, zu ndern oder zu entfernen, auer der gerade besuchten Eigenschaft. Die Spezifikation erlaubt es explizit, dass die Implementierung dem Algorithmus in einem der folgenden Flle nicht folgt:

• Die Prototypenkette des Objekts wird whrend der Iteration gendert.
• Eine Eigenschaft wird whrend der Iteration aus dem Objekt oder seiner Prototypenkette entfernt.
• Eine Eigenschaft wird whrend der Iteration in die Prototypenkette des Objekts hinzugefgt.
• Die Aufzhlbarkeit einer Eigenschaft wird whrend der Iteration gendert.

In diesen Fllen knnen sich die Implementierungen anders verhalten, als Sie es erwarten, oder sogar voneinander abweichen.

Array-Iteration und for...in

Array-Indizes sind einfach aufzhlbare Eigenschaften mit ganzzahligen Namen und ansonsten identisch mit allgemeinen Objekteigenschaften. Die for...in Schleife wird alle ganzzahligen Schlssel in streng aufsteigender Reihenfolge vor anderen Schlsseln durchlaufen, wodurch das Verhalten von for...in der normalen Array-Iteration nahe kommt. However, die for...in Schleife gibt alle aufzhlbaren Eigenschaften zurck, einschlielich derjenigen mit nicht-ganzzahligen Namen und der geerbten Eigenschaften. Im Gegensatz zu for...of verwendet for...in die Eigenschaftsaufzhlung statt des Array-Iterators. In dnnbesetzten Arrays wird for...of die leeren Pltze besuchen, for...in jedoch nicht.

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 zurckgeben und nicht-Index-Eigenschaften vermeiden.

Iteration nur ber eigene Eigenschaften

Wenn Sie nur die zum Objekt selbst gehrenden Eigenschaften, nicht aber die seiner Prototypen bercksichtigen mchten, knnen Sie eine der folgenden Techniken verwenden:

• Object.keys()
• Object.getOwnPropertyNames()

Object.keys gibt eine Liste der aufzhlbaren eigenen Zeichenketteneigenschaften zurck, whrend Object.getOwnPropertyNames auch nicht-auflistbare Eigenschaften enthlt.

Viele JavaScript-Stilhandbcher und Linter empfehlen, die Verwendung von for...in zu vermeiden, da es ber die gesamte Prototypenkette iteriert, was selten gewnscht ist, und mit der weiter verbreiteten for...of Schleife verwechselt werden knnte. for...in wird am praktischsten fr Debugging-Zwecke verwendet, da es eine einfache Mglichkeit bietet, die Eigenschaften eines Objekts zu berprfen (indem sie in die Konsole ausgegeben werden oder auf andere Weise). In Situationen, in denen Objekte als Ad-hoc-Schlssel-Wert-Paare verwendet werden, knnen Sie mit for...in berprfen, ob einer dieser Schlssel einen bestimmten Wert hlt.

Beispiele

Verwendung von for...in

Die folgende for...in Schleife iteriert ber alle aufzhlbaren 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 von Object.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 whrend der Iteration zum aktuellen Objekt hinzugefgt 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.

Darber hinaus bercksichtigen Sie die folgenden Flle, in denen das Verhalten nicht spezifiziert ist und die Implementierungen dazu neigen, von dem spezifizierten Algorithmus abzuweichen:

ndern des Prototyps whrend der Iteration:

const obj = { a: 1, b: 2 };

for (const prop in obj) {
  console.log(`obj.${prop} = ${obj[prop]}`);
  Object.setPrototypeOf(obj, { c: 3 });
}

Lschen einer Eigenschaft whrend 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;
}

Aufzhlbare Eigenschaften, die whrend der Iteration zum Prototyp hinzugefgt 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 Aufzhlbarkeit einer Eigenschaft whrend 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-Kompatibilitt

Siehe auch

• for...of
• for
• Aufzhlbarkeit und Eigentmerschaft von Eigenschaften
• Object.getOwnPropertyNames()
• Object.hasOwn()
• Array.prototype.forEach()