Derin Operator gibttrue zurück, wenn die angegebene Eigenschaft im angegebenen Objekt oder in dessen Prototypenkette vorhanden ist.

Derin Operator kann nicht verwendet werden, um nach Werten in anderen Sammlungen zu suchen. Um zu testen, ob ein bestimmter Wert in einem Array existiert, verwenden SieArray.prototype.includes(). Für Sets verwenden SieSet.prototype.has().

Probieren Sie es aus

const car = { make: "Honda", model: "Accord", year: 1998 };console.log("make" in car);// Expected output: truedelete car.make;if ("make" in car === false) {  car.make = "Suzuki";}console.log(car.make);// Expected output: "Suzuki"

Syntax

prop in object#prop in object

Parameter

prop

Ein String oder Symbol, das einen Eigenschaftsnamen darstellt (nicht-Symbole werdenzu Strings konvertiert). Kann auch einprivater Element-Identifikator sein.

object

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

Ausnahmen

TypeError

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

Beschreibung

Derin Operator prüft, ob eine String- oder Symbol-Eigenschaft in einem Objekt oder in dessen Prototypenkette vorhanden ist. Wenn Sie nurnicht-vererbte Eigenschaften prüfen möchten, verwenden SieObject.hasOwn() stattdessen.

Eine Eigenschaft kann in einem Objekt vorhanden sein, aber den Wertundefined haben. Daher ist"x" in obj nicht dasselbe wieobj.x !== undefined. Umin dazu zu bringen,false zurückzugeben, nachdem eine Eigenschaft hinzugefügt wurde, verwenden Sie dendelete Operator anstelle davon, den Wert dieser Eigenschaft aufundefined zu setzen.

Sie können auch denin Operator verwenden, um zu überprüfen, ob ein bestimmtesprivates Klassenfeld oder Methode in einem Objekt definiert wurde. Der Operator gibttrue zurück, wenn die Eigenschaft definiert ist, undfalse andernfalls. Dies wird alsbranding-Prüfung bezeichnet, da sietrue zurückgibt, wenn und nur wenn das Objekt mit diesem Klassenkonstruktor erstellt wurde, wonach Sie sicher auf andere private Elemente zugreifen können.

Dies ist eine spezielle Syntax — die linke Seite desin Operators ist ein Eigenschaftsidentifikator anstelle eines Ausdrucks, aber unzitiert (da es sonst eine String-Eigenschaft und kein privates Element wäre).

Da auf private Elemente in Objekten, die nicht mit der aktuellen Klasse verwandt sind, einTypeError geworfen wird, anstelle vonundefined zurückgegeben wird, ermöglicht diese Syntax Ihnen, zu verkü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 im Allgemeinen auch die Notwendigkeit, mit der Fehlerbehandlung umzugehen, nur um auf ein möglicherweise nicht existentes privates Element zuzugreifen.

Derin Operator erfordert jedoch immer noch, dass das private Element vorher in der umgebenden Klasse deklariert wird — andernfalls würde er einenSyntaxError werfen ("Privates Feld '#x' muss in einer umgebenden Klasse deklariert werden"), derselbe wie wenn Sie versuchen, auf ein nicht deklariertes privates Element zuzugreifen.

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

Beispiele

Grundlegende Verwendung

Die folgenden Beispiele zeigen einige Verwendungen desin Operators.

// Arraysconst trees = ["redwood", "bay", "cedar", "oak", "maple"];0 in trees; // returns true3 in trees; // returns true6 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 objectsconst myCar = { make: "Honda", model: "Accord", year: 1998 };"make" in myCar; // returns true"model" in myCar; // returns true

Sie müssen ein Objekt auf der rechten Seite desin Operators angeben. Zum Beispiel können Sie eine Zeichenfolge angeben, die mit demString Konstruktor erstellt wurde, aber Sie können keine Zeichenfolgenliterale angeben.

const color1 = new String("green");"length" in color1; // returns trueconst color2 = "coral";// generates an error (color2 is not a String object)"length" in color2;

Verwendung des in Operators mit gelöschten oder undefinierten Eigenschaften

Wenn Sie eine Eigenschaft mit demdelete Operator löschen, gibt derin Operator für diese Eigenschaftfalse zurück.

const myCar = { make: "Honda", model: "Accord", year: 1998 };delete myCar.make;"make" in myCar; // returns falseconst trees = ["redwood", "bay", "cedar", "oak", "maple"];delete trees[3];3 in trees; // returns false

Wenn Sie eine Eigenschaft aufundefined setzen, sie jedoch nicht löschen, gibt derin Operator für diese Eigenschafttrue 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

Derin Operator wirdfalse fürleere Array-Slots zurückgeben, auch wenn der direkte Zugriff daraufundefined zurückgibt.

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

Um dies zu vermeiden, stellen Sie sicher, dass ein neues Array immer mit nicht-leeren Werten gefüllt wird oder nicht auf Indizes hinter dem Ende des Arrays geschrieben wird.

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

Vererbte Eigenschaften

Derin Operator gibttrue für Eigenschaften in der Prototypenkette zurück. Dies kann unerwünscht sein, wenn Sie Objekte verwenden, um beliebige Schlüssel-Wert-Paare zu speichern.

const ages = { alice: 18, bob: 27 };function hasPerson(name) {  return name in ages;}hasPerson("hasOwnProperty"); // true

Sie könnenObject.hasOwn() verwenden, um zu prü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 erwägen, einNull-Prototyp-Objekt oder eineMap zum Speichern vonages 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

Verwenden des in Operators zur Implementierung von Branding-Prüfungen

Der folgende Code-Ausschnitt demonstriert eine statische Funktion, die angibt, ob ein Objekt mit demPerson 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)); // -10console.log(Person.isPerson(p1)); // trueif (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 denin Operator müssten Sie einentry...catch Block verwenden, um zu prüfen, ob das Objekt das private Element hat.

Sie können dies auch als eine[Symbol.hasInstance]() Methode der Klasse implementieren, sodass Sie deninstanceof Operator verwenden können, um dieselbe Prüfung durchzuführen (die standardmäßig nur auf die Existenz vonPerson.prototype in der Prototypenkette des Objekts prü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 siehePrivate Elemente und denKlassenguide.

Spezifikationen

Browser-Kompatibilität

Siehe auch

• for...in
• delete
• Object.hasOwn()
• Reflect.has()
• Enumerierbarkeit und Eigentümerschaft von Eigenschaften