in

prop

Ein String oder Symbol, das einen Eigenschaftsnamen darstellt (Nicht-Symbole werden zu Strings konvertiert). Kann auch ein privater Eigenschaftsidentifikator sein.

object

Objekt, um zu überprüfen, ob es (oder dessen Prototypen-Kette) 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 überprüft, ob eine String- oder Symbol-Eigenschaft in einem Objekt oder dessen Prototypen-Kette vorhanden ist. Wenn Sie nur nicht-geerbte Eigenschaften überprüfen möchten, verwenden Sie stattdessen 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 zu erreichen, dass in nach dem Hinzufügen einer Eigenschaft false zurückgibt, verwenden Sie den delete Operator, anstatt den Wert dieser 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 andernfalls. Dies wird als gekennzeichnete Prüfung bezeichnet, da es true zurückgibt, wenn und nur wenn das Objekt mit diesem Klassenkonstruktor erstellt wurde, wonach Sie auch sicher auf andere private Eigenschaften zugreifen können.

Dies ist eine spezielle Syntax — auf der linken Seite des in Operators befindet sich ein Eigenschaftsidentifikator statt eines Ausdrucks, jedoch unzitiert (da es sonst eine String-Eigenschaft wäre, keine private Eigenschaft).

Da der Zugriff auf private Eigenschaften von Objekten, die nicht mit der aktuellen Klasse zusammenhängen, einen TypeError auslöst, anstatt undefined zurückzugeben, ermöglicht diese Syntax die Verkürzung von:

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 im Allgemeinen die Notwendigkeit, mit Fehlerbehandlung umzugehen, nur um auf eine möglicherweise nicht vorhandene private Eigenschaft zuzugreifen.

Der in Operator erfordert jedoch immer noch, dass die private Eigenschaft zuvor in der umgebenden Klasse deklariert wurde — andernfalls würde er einen SyntaxError auslösen ("Private field '#x' must be declared in an enclosing class"), denselben, wie 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 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

Auf der rechten Seite des in Operators müssen Sie ein Objekt angeben. Zum Beispiel können Sie einen String angeben, der mit dem String-Konstruktor erstellt wurde, aber keinen String-Literal.

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 eine Eigenschaft auf undefined setzen, sie aber nicht löschen, gibt der in Operator für diese Eigenschaft true 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 gibt false für leere Array-Slots zurück, auch wenn der direkte Zugriff undefined zurückgibt.

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 gefüllt ist oder schreiben Sie nicht auf Indizes hinter dem Ende des Arrays.

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

Der in Operator gibt true für Eigenschaften in der Prototypen-Kette 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önnen Object.hasOwn() verwenden, um zu überprüfen, ob das Objekt den Schlüssel besitzt.

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

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

hasPerson("hasOwnProperty"); // false

Alternativ sollten Sie in Betracht ziehen, ein Objekt mit Null-Prototyp oder eine Map für die 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 untenstehende Codeausschnitt demonstriert eine statische Funktion, die feststellt, 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 prüfen, ob das Objekt die private Eigenschaft besitzt.

Sie können dies auch als [Symbol.hasInstance]() Methode der Klasse implementieren, sodass Sie den instanceof Operator verwenden können, um dieselbe Prüfung durchzuführen (die standardmäßig nur auf die Existenz von Person.prototype in der Prototypenkette 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 Eigenschaften und den Klassen-Leitfaden.

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