in

Probieren Sie es aus

const car = { make: "Honda", model: "Accord", year: 1998 };

console.log("make" in car);
// Expected output: true

delete 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 werden zu Strings konvertiert). Kann auch ein privater Element-Identifikator sein.

object

Objekt, das berprft werden soll, ob es (oder seine Prototypenkette) die Eigenschaft mit dem angegebenen Namen (prop) enthlt.

Ausnahmen

TypeError

Wird ausgelst, wenn object kein Objekt ist (d.h. ein primitiver Wert).

Beschreibung

Der in Operator prft, ob eine String- oder Symbol-Eigenschaft in einem Objekt oder in dessen Prototypenkette vorhanden ist. Wenn Sie nur nicht-vererbte Eigenschaften prfen mchten, verwenden Sie Object.hasOwn() stattdessen.

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 dazu zu bringen, false zurckzugeben, nachdem eine Eigenschaft hinzugefgt wurde, verwenden Sie den delete Operator anstelle davon, den Wert dieser Eigenschaft auf undefined zu setzen.

Sie knnen auch den in Operator verwenden, um zu berprfen, ob ein bestimmtes privates Klassenfeld oder Methode in einem Objekt definiert wurde. Der Operator gibt true zurck, wenn die Eigenschaft definiert ist, und false andernfalls. Dies wird als branding-Prfung bezeichnet, da sie true zurckgibt, wenn und nur wenn das Objekt mit diesem Klassenkonstruktor erstellt wurde, wonach Sie sicher auf andere private Elemente zugreifen knnen.

Dies ist eine spezielle Syntax die linke Seite des in Operators ist ein Eigenschaftsidentifikator anstelle eines Ausdrucks, aber unzitiert (da es sonst eine String-Eigenschaft und kein privates Element wre).

Da auf private Elemente in Objekten, die nicht mit der aktuellen Klasse verwandt sind, ein TypeError geworfen wird, anstelle von undefined zurckgegeben wird, ermglicht diese Syntax Ihnen, zu verkrzen:

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 mglicherweise nicht existentes privates Element zuzugreifen.

Der in Operator erfordert jedoch immer noch, dass das private Element vorher in der umgebenden Klasse deklariert wird andernfalls wrde er einen SyntaxError 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 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 mssen ein Objekt auf der rechten Seite des in Operators angeben. Zum Beispiel knnen Sie eine Zeichenfolge angeben, die mit dem String Konstruktor erstellt wurde, aber Sie knnen keine Zeichenfolgenliterale angeben.

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;

Verwendung des in Operators mit gelschten oder undefinierten Eigenschaften

Wenn Sie eine Eigenschaft mit dem delete Operator lschen, gibt der in Operator fr diese Eigenschaft false zurck.

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 eine Eigenschaft auf undefined setzen, sie jedoch nicht lschen, gibt der in Operator fr diese Eigenschaft true zurck.

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 false fr leere Array-Slots zurckgeben, auch wenn der direkte Zugriff darauf undefined zurckgibt.

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-leeren Werten gefllt 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

Der in Operator gibt true fr Eigenschaften in der Prototypenkette zurck. Dies kann unerwnscht sein, wenn Sie Objekte verwenden, um beliebige Schlssel-Wert-Paare zu speichern.

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

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

hasPerson("hasOwnProperty"); // true

Sie knnen Object.hasOwn() verwenden, um zu prfen, ob das Objekt den Schlssel hat.

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

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

hasPerson("hasOwnProperty"); // false

Alternativ sollten Sie erwgen, ein Null-Prototyp-Objekt oder eine Map zum Speichern 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

Verwenden des in Operators zur Implementierung von Branding-Prfungen

Der folgende Code-Ausschnitt demonstriert eine statische Funktion, die angibt, ob ein Objekt mit dem Person Konstruktor erstellt wurde und daher andere Methoden sicher ausfhren 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 mssten Sie einen try...catch Block verwenden, um zu prfen, ob das Objekt das private Element hat.

Sie knnen dies auch als eine [Symbol.hasInstance]() Methode der Klasse implementieren, sodass Sie den instanceof Operator verwenden knnen, um dieselbe Prfung durchzufhren (die standardmig nur auf die Existenz von Person.prototype in der Prototypenkette des Objekts prft).

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
}

Fr weitere Beispiele siehe Private Elemente und den Klassenguide.

Spezifikationen

Browser-Kompatibilitt

Siehe auch

• for...in
• delete
• Object.hasOwn()
• Reflect.has()
• Enumerierbarkeit und Eigentmerschaft von Eigenschaften