HTML: Markup language
CSS: Styling language
JavaScript: Scripting language
Web APIs: Programming interfaces
All web technology
Learn web development
Discover our tools
Get to know MDN better
Dieser Inhalt wurde automatisch aus dem Englischen übersetzt, und kann Fehler enthalten. Erfahre mehr über dieses Experiment.
View in English Always switch to English
Diese Funktion ist gut etabliert und funktioniert auf vielen Geräten und in vielen Browserversionen. Sie ist seit Juli 2015 browserübergreifend verfügbar.
Der in Operator gibt true zurück, wenn die angegebene Eigenschaft im angegebenen Objekt oder in dessen Prototypenkette vorhanden ist.
in
true
Der in 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 Sie Array.prototype.includes(). Für Sets verwenden Sie Set.prototype.has().
Array.prototype.includes()
Set.prototype.has()
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"
prop in object #prop in object
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 überprüft werden soll, ob es (oder seine Prototypenkette) 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 Symbol-Eigenschaft in einem Objekt oder in dessen Prototypenkette vorhanden ist. Wenn Sie nur nicht-vererbte Eigenschaften prüfen möchten, verwenden Sie Object.hasOwn() 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 in dazu zu bringen, false zurückzugeben, nachdem eine Eigenschaft hinzugefügt wurde, verwenden Sie den delete Operator anstelle davon, den Wert dieser Eigenschaft auf undefined zu setzen.
undefined
"x" in obj
obj.x !== undefined
false
delete
Sie können auch den in Operator verwenden, um zu überprüfen, ob ein bestimmtes privates Klassenfeld oder Methode in einem Objekt definiert wurde. Der Operator gibt true zurück, wenn die Eigenschaft definiert ist, und false andernfalls. Dies wird als branding-Prüfung bezeichnet, da sie true 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 des in 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, ein TypeError geworfen wird, anstelle von undefined 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.
Der in Operator erfordert jedoch immer noch, dass das private Element vorher in der umgebenden Klasse deklariert wird — andernfalls würde 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.
SyntaxError
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
Sie müssen ein Objekt auf der rechten Seite des in Operators angeben. Zum Beispiel können Sie eine Zeichenfolge angeben, die mit dem String Konstruktor erstellt wurde, aber Sie können keine Zeichenfolgenliterale angeben.
String
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 jedoch 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 wird false für leere Array-Slots zurückgeben, auch wenn der direkte Zugriff darauf 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 wird oder nicht auf Indizes hinter dem Ende des Arrays geschrieben wird.
const empties = new Array(3).fill(undefined); 2 in empties; // returns true
Der in Operator gibt true 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önnen Object.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, ein Null-Prototyp-Objekt oder eine Map zum Speichern von ages zu verwenden, um andere Fehler zu vermeiden.
Map
ages
const ages = new Map([ ["alice", 18], ["bob", 27], ]); function hasPerson(name) { return ages.has(name); } hasPerson("hasOwnProperty"); // false
Der folgende Code-Ausschnitt demonstriert eine statische Funktion, die angibt, ob ein Objekt mit dem Person Konstruktor erstellt wurde und daher andere Methoden sicher ausführen kann.
Person
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 das private Element hat.
try...catch
Sie können dies auch als eine [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 prüft).
[Symbol.hasInstance]()
instanceof
Person.prototype
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 Elemente und den Klassenguide.
JavaScript aktivieren, um diese Browser-Kompatibilitätstabelle anzuzeigen.
for...in
Reflect.has()