in

prop

Ein String oder Symbol, das einen Eigenschaftsnamen repräsentiert (Nicht-Symbole werden zu Strings umgewandelt). Kann auch ein privater Eigenschaften-Identifikator sein.

object

Objekt, das überprüft werden soll, ob es (oder seine Prototypkette) die Eigenschaft mit dem angegebenen Namen (prop) enthält.

TypeError

Wird ausgelöst, wenn object kein Objekt ist (d.h. ein primitiver Wert).

Der in Operator prüft, ob eine String- oder Symboleigenschaft in einem Objekt oder seiner Prototypkette vorhanden ist. Wenn Sie nur auf nicht-geerbte Eigenschaften prüfen möchten, verwenden Sie Object.hasOwn().

Eine Eigenschaft kann in einem Objekt vorhanden sein, aber den Wert undefined haben. Daher ist "x" in obj nicht dasselbe wie obj.x !== undefined. Um in nach dem Hinzufügen einer Eigenschaft false zurückgeben zu lassen, verwenden Sie den delete Operator anstelle davon, den Wert der Eigenschaft auf undefined zu setzen.

Sie können den in Operator auch verwenden, um zu überprüfen, ob ein bestimmtes privates Klassenfeld oder eine Methode in einem Objekt definiert wurde. Der Operator gibt true zurück, wenn die Eigenschaft definiert ist, und false, wenn nicht. Dies wird als ein gebranntmarkter Check bezeichnet, da er true zurückgibt, wenn und nur wenn das Objekt mit diesem Klassenkonstruktor erstellt wurde, wodurch Sie sicher auf andere private Eigenschaften zugreifen können.

Dies ist eine spezielle Syntax — die linke Seite des in Operators ist ein Eigenschaften-Identifikator anstelle eines Ausdrucks, aber unzitiert (weil es sonst eine String-Eigenschaft wäre, keine private Eigenschaft).

Da der Zugriff auf private Eigenschaften von Objekten, die nicht zur aktuellen Klasse gehören, einen TypeError auslöst, anstatt undefined zurückzugeben, ermöglicht Ihnen diese Syntax, abzukürzen:

class C {
  #x;
  static isC(obj) {
    try {
      obj.#x;
      return true;
    } catch {
      return false;
    }
  }
}

Zu:

class C {
  #x;
  static isC(obj) {
    return #x in obj;
  }
}

Es vermeidet auch allgemein die Notwendigkeit, Fehlerbehandlung zu betreiben, nur um auf eine möglicherweise nicht existierende private Eigenschaft zuzugreifen.

Der in Operator erfordert jedoch immer noch, dass die private Eigenschaft vorher in der umschließenden Klasse deklariert wird — ansonsten würde er einen SyntaxError auslösen ("Privates Feld '#x' muss in einer umschließenden Klasse deklariert werden"), denselben Fehler, den Sie erhalten, wenn Sie versuchen, auf eine nicht deklarierte private Eigenschaft zuzugreifen.

class C {
  foo() {
    #x in this;
  }
}

new C().foo(); // SyntaxError: Private field '#x' must be declared in an enclosing class

Die folgenden Beispiele zeigen einige Anwendungen des in Operators.

// Arrays
const trees = ["redwood", "bay", "cedar", "oak", "maple"];
0 in trees; // returns true
3 in trees; // returns true
6 in trees; // returns false
"bay" in trees; // returns false (you must specify the index number, not the value at that index)
"length" in trees; // returns true (length is an Array property)
Symbol.iterator in trees; // returns true

// Predefined objects
"PI" in Math; // returns true

// Custom objects
const myCar = { make: "Honda", model: "Accord", year: 1998 };
"make" in myCar; // returns true
"model" in myCar; // returns true

Sie müssen auf der rechten Seite des in Operators ein Objekt angeben. Zum Beispiel können Sie eine mit dem String Konstruktor erstellte Zeichenkette angeben, aber keine Zeichenkettenliterale.

const color1 = new String("green");
"length" in color1; // returns true

const color2 = "coral";
// generates an error (color2 is not a String object)
"length" in color2;

Wenn Sie eine Eigenschaft mit dem delete Operator löschen, gibt der in Operator für diese Eigenschaft false zurück.

const myCar = { make: "Honda", model: "Accord", year: 1998 };
delete myCar.make;
"make" in myCar; // returns false

const trees = ["redwood", "bay", "cedar", "oak", "maple"];
delete trees[3];
3 in trees; // returns false

Wenn Sie jedoch eine Eigenschaft auf undefined setzen, aber nicht löschen, gibt der in Operator für diese Eigenschaft wahr zurück.

const myCar = { make: "Honda", model: "Accord", year: 1998 };
myCar.make = undefined;
"make" in myCar; // returns true

const trees = ["redwood", "bay", "cedar", "oak", "maple"];
trees[3] = undefined;
3 in trees; // returns true

Der in Operator wird für leere Array-Plätze false zurückgeben, selbst wenn der direkte Zugriff undefined ergibt.

const empties = new Array(3);
empties[2]; // returns undefined
2 in empties; // returns false

Um dies zu vermeiden, stellen Sie sicher, dass ein neues Array immer mit Nicht-Leerwerten gefüllt ist oder nicht über die Enden des Arrays zu schreiben.

const empties = new Array(3).fill(undefined);
2 in empties; // returns true

Der in Operator gibt true für Eigenschaften in der Prototypkette zurück. Dies kann unerwünscht sein, wenn Sie Objekte zur Speicherung arbiträrer Schlüssel-Wert-Paare verwenden.

const ages = { alice: 18, bob: 27 };

function hasPerson(name) {
  return name in ages;
}

hasPerson("hasOwnProperty"); // true

Sie können Object.hasOwn() verwenden, um zu überprüfen, ob das Objekt den Schlüssel hat.

const ages = { alice: 18, bob: 27 };

function hasPerson(name) {
  return Object.hasOwn(ages, name);
}

hasPerson("hasOwnProperty"); // false

Alternativ sollten Sie in Erwägung ziehen, ein Null-Prototyp-Objekt oder eine Map zur Speicherung von ages zu verwenden, um andere Fehler zu vermeiden.

const ages = new Map([
  ["alice", 18],
  ["bob", 27],
]);

function hasPerson(name) {
  return ages.has(name);
}

hasPerson("hasOwnProperty"); // false

Der folgende Codeausschnitt zeigt eine statische Funktion, die erkennt, ob ein Objekt mit dem Person Konstruktor erstellt wurde und daher andere Methoden sicher ausführen kann.

class Person {
  #age;
  constructor(age) {
    this.#age = age;
  }
  static isPerson(o) {
    return #age in o;
  }
  ageDifference(other) {
    return this.#age - other.#age;
  }
}

const p1 = new Person(20);
const p2 = new Person(30);
console.log(p1.ageDifference(p2)); // -10
console.log(Person.isPerson(p1)); // true

if (Person.isPerson(p1) && Person.isPerson(p2)) {
  console.log(p1.ageDifference(p2)); // -10
}

Es hilft, den folgenden Fall zu verhindern:

const p2 = {};

p1.ageDifference(p2); // TypeError: Cannot read private member #age from an object whose class did not declare it

Ohne den in Operator müssten Sie einen try...catch Block verwenden, um zu überprüfen, ob das Objekt die private Eigenschaft hat.

Sie können dies auch als eine [Symbol.hasInstance]() Methode der Klasse implementieren, sodass Sie den instanceof Operator verwenden können, um denselben Check auszuführen (der standardmäßig nur das Vorhandensein von Person.prototype in der Prototypkette des Objekts überprüft).

class Person {
  #age;
  constructor(age) {
    this.#age = age;
  }
  static [Symbol.hasInstance](o) {
    // Testing `this` to prevent false-positives when
    // calling `instanceof SubclassOfPerson`
    return this === Person && #age in o;
  }
  ageDifference(other) {
    return this.#age - other.#age;
  }
}

const p1 = new Person(20);
const p2 = new Person(30);

if (p1 instanceof Person && p2 instanceof Person) {
  console.log(p1.ageDifference(p2)); // -10
}

Für weitere Beispiele, siehe Private properties und den Klassen-Leitfaden.

• for...in
• delete
• Object.hasOwn()
• Reflect.has()
• Aufzählbarkeit und Besitz von Eigenschaften