DerObject-Typ stellt einen vonJavaScripts Datentypen dar. Er wird verwendet, um verschiedene schlüsselbasierte Sammlungen und komplexere Einheiten zu speichern. Objekte können mit demObject()-Konstruktor oder derObjektinitialisierer / Literal-Syntax erstellt werden.

Beschreibung

Nahezu alleObjekte in JavaScript sind Instanzen vonObject; ein typisches Objekt erbt Eigenschaften (einschließlich Methoden) vonObject.prototype, obwohl diese Eigenschaften möglicherweise überschattet (d.h. überschrieben) werden können. Die einzigen Objekte, die nicht vonObject.prototype erben, sind diejenigen mitnull Prototype oder die von anderennull Prototype-Objekten abstammen.

Änderungen amObject.prototype-Objekt sind durch das Prototypen-Chaining beiallen Objekten sichtbar, es sei denn, die von diesen Änderungen betroffenen Eigenschaften und Methoden werden weiter entlang der Prototypenkette überschrieben. Dies bietet eine sehr leistungsstarke, obwohlpotenziell gefährliche Mechanismus, um das Verhalten von Objekten zu überschreiben oder zu erweitern. Um es sicherer zu machen, istObject.prototype das einzige Objekt in der Kern-JavaScript-Sprache, das einunveränderliches Prototype hat — das Prototype vonObject.prototype ist immernull und nicht änderbar.

Objekt-Prototyp-Eigenschaften

Sie sollten vermeiden, Methoden vonObject.prototype direkt aus einer Instanz aufzurufen, insbesondere solche, die nicht polymorph sein sollen (d.h. nur ihr anfängliches Verhalten macht Sinn, und kein nachfolgendes Objekt könnte es auf sinnvolle Weise überschreiben). Alle vonObject.prototype abgeleiteten Objekte können eine benutzerdefinierte eigene Eigenschaft mit demselben Namen definieren, aber mit völlig unterschiedlichen Semantiken als erwartet. Außerdem werden diese Eigenschaften nicht vonnull Prototype-Objekten geerbt. Alle modernen JavaScript-Dienstprogramme zur Arbeit mit Objekten sindstatisch. Genauer gesagt:

• valueOf(),toString() undtoLocaleString() existieren, um polymorph zu sein. Sie sollten erwarten, dass das Objekt seine eigene Implementierung mit sinnvollen Verhaltensweisen definiert, sodass Sie sie als Instanzmethoden aufrufen können. Häufig werden jedochvalueOf() undtoString() implizit durchTypumwandlung aufgerufen, sodass Sie sie in Ihrem Code nicht selbst aufrufen müssen.
• __defineGetter__(),__defineSetter__(),__lookupGetter__() und__lookupSetter__() sind veraltet und sollten nicht verwendet werden. Verwenden Sie die statischen AlternativenObject.defineProperty() undObject.getOwnPropertyDescriptor().
• Die__proto__-Eigenschaft ist veraltet und sollte nicht verwendet werden. Die AlternativenObject.getPrototypeOf() undObject.setPrototypeOf() sind statische Methoden.
• Die MethodenpropertyIsEnumerable() undhasOwnProperty() können durch die statischen MethodenObject.getOwnPropertyDescriptor() bzw.Object.hasOwn() ersetzt werden.
• Die MethodeisPrototypeOf() kann normalerweise durchinstanceof ersetzt werden, wenn Sie dieprototype-Eigenschaft eines Konstruktors überprüfen.

Falls keine semantisch äquivalente statische Methode existiert oder Sie dieObject.prototype-Methode wirklich verwenden möchten, sollten Sie dieObject.prototype-Methode stattdessen direktcall() auf Ihr Zielobjekt anwenden, um zu verhindern, dass das Objekt eine überschreibende Eigenschaft enthält, die unerwartete Ergebnisse liefert.

const obj = {  foo: 1,  // You should not define such a method on your own object,  // but you may not be able to prevent it from happening if  // you are receiving the object from external input  propertyIsEnumerable() {    return false;  },};obj.propertyIsEnumerable("foo"); // false; unexpected resultObject.prototype.propertyIsEnumerable.call(obj, "foo"); // true; expected result

Löschen einer Eigenschaft aus einem Objekt

Es gibt keine Methode innerhalb eines Objekts, um seine eigenen Eigenschaften zu löschen (wie etwaMap.prototype.delete()). Stattdessen muss derdelete-Operator verwendet werden.

Null-Prototyp-Objekte

Fast alle Objekte in JavaScript erben letztlich vonObject.prototype (sieheVererbung und die Prototypenkette). Sie können jedoch null-Prototyp-Objekte mitObject.create(null) oder derObjektinitialisierungs-Syntax mit__proto__: null erstellen (Hinweis: Der__proto__ Schlüssel in Objektliteralen unterscheidet sich von der veraltetenObject.prototype.__proto__-Eigenschaft). Sie können auch den Prototyp eines bestehenden Objekts aufnull ändern, indem SieObject.setPrototypeOf(obj, null) aufrufen.

const obj = Object.create(null);const obj2 = { __proto__: null };

Ein Objekt mit einemnull-Prototyp kann sich in unerwarteter Weise verhalten, da es keine Objektmethoden vonObject.prototype erbt. Dies trifft insbesondere bei der Fehlersuche zu, da gängige Objekt-Eigenschaft-Umwandlungs-/Erkennungs-Dienstprogramme Fehler erzeugen oder Informationen verlieren können (besonders bei stillschweigenden Fehlerschleifen, die Fehler ignorieren).

Zum Beispiel führt das Fehlen vonObject.prototype.toString() oft dazu, dass Fehlersuche nicht durchführbar ist:

const normalObj = {}; // create a normal objectconst nullProtoObj = Object.create(null); // create an object with "null" prototypeconsole.log(`normalObj is: ${normalObj}`); // shows "normalObj is: [object Object]"console.log(`nullProtoObj is: ${nullProtoObj}`); // throws error: Cannot convert object to primitive valuealert(normalObj); // shows [object Object]alert(nullProtoObj); // throws error: Cannot convert object to primitive value

Andere Methoden werden ebenfalls fehlschlagen.

normalObj.valueOf(); // shows {}nullProtoObj.valueOf(); // throws error: nullProtoObj.valueOf is not a functionnormalObj.hasOwnProperty("p"); // shows "true"nullProtoObj.hasOwnProperty("p"); // throws error: nullProtoObj.hasOwnProperty is not a functionnormalObj.constructor; // shows "Object() { [native code] }"nullProtoObj.constructor; // shows "undefined"

Wir können dietoString-Methode dem Null-Prototyp-Objekt hinzufügen, indem wir sie zuweisen:

nullProtoObj.toString = Object.prototype.toString; // since new object lacks toString, add the original generic one backconsole.log(nullProtoObj.toString()); // shows "[object Object]"console.log(`nullProtoObj is: ${nullProtoObj}`); // shows "nullProtoObj is: [object Object]"

Im Gegensatz zu normalen Objekten, bei denentoString() im Prototyp des Objekts existiert, ist dietoString()-Methode hier eine eigene Eigenschaft vonnullProtoObj. Dies liegt daran, dassnullProtoObj keinen (null) Prototyp hat.

Man kann ein Null-Prototyp-Objekt auch in ein gewöhnliches Objekt zurückverwandeln, indem manObject.setPrototypeOf(nullProtoObj, Object.prototype) aufruft.

In der Praxis werden Objekte mitnull-Prototyp meist als günstiger Ersatz fürMaps verwendet. Das Vorhandensein vonObject.prototype-Eigenschaften kann einige Fehler verursachen:

const ages = { alice: 18, bob: 27 };function hasPerson(name) {  return name in ages;}function getAge(name) {  return ages[name];}hasPerson("hasOwnProperty"); // truegetAge("toString"); // [Function: toString]

Die Verwendung eines Null-Prototyp-Objekts beseitigt dieses Risiko, ohne allzu viel Komplexität in diehasPerson- undgetAge-Funktionen einzuführen:

const ages = Object.create(null, {  alice: { value: 18, enumerable: true },  bob: { value: 27, enumerable: true },});hasPerson("hasOwnProperty"); // falsegetAge("toString"); // undefined

In einem solchen Fall sollte die Hinzufügung jeder Methode mit Vorsicht erfolgen, da sie mit anderen als Daten gespeicherten Schlüssel-Wert-Paaren verwechselt werden kann.

Außerdem verhindert das Erstellen eines Objekts, das nicht vonObject.prototype erbt,Prototype Pollution-Angriffe. Wenn ein bösartiges Skript eine Eigenschaft zuObject.prototype hinzufügt, ist sie bei jedem Objekt in Ihrem Programm zugänglich, außer Objekten mit Null-Prototyp.

const user = {};// A malicious script:Object.prototype.authenticated = true;// Unexpectedly allowing unauthenticated user to pass throughif (user.authenticated) {  // access confidential data}

JavaScript hat auch integrierte APIs, dienull-Prototyp-Objekte erzeugen, insbesondere solche, die Objekte als Ad-hoc-Schlüsselwertsammlungen verwenden. Zum Beispiel:

• Der Rückgabewert vonObject.groupBy()
• Diegroups- undindices.groups-Eigenschaften des Ergebnisses vonRegExp.prototype.exec()
• Array.prototype[Symbol.unscopables] (alle[Symbol.unscopables] Objekte sollten einennull Prototype haben)
• import.meta
• Modul-Namensraum-Objekte, die durchimport * as ns from "module"; oderimport() erhalten werden

Der Begriff "null-Prototyp-Objekt" inkludiert oft auch jedes Objekt ohneObject.prototype in seiner Prototypenkette. Solche Objekte können mitextends null bei der Verwendung von Klassen erstellt werden.

Objektumwandlung

Viele eingebaute Operationen, die Objekte erwarten, konvertieren ihre Argumente zuerst in Objekte. DieOperation kann zusammengefasst werden wie folgt:

• Objekte werden unverändert zurückgegeben.
• undefined undnull werfen einenTypeError.
• Number,String,Boolean,Symbol,BigInt-Primitiven werden in ihre entsprechenden Objekt-Wrapper eingebunden.

Es gibt zwei Möglichkeiten, fast denselben Effekt in JavaScript zu erzielen.

• Object.prototype.valueOf():Object.prototype.valueOf.call(x) führt genau die oben beschriebenen Objekterzwingungsschritte durch, umx zu konvertieren.
• DieObject()-Funktion:Object(x) verwendet denselben Algorithmus zur Konvertierung vonx, mit der Ausnahme, dassundefined undnull keinenTypeError werfen, sondern ein einfaches Objekt zurückgeben.

Stellen, an denen Objekterzwingung verwendet wird, umfassen:

• Denobject-Parameter vonfor...in-Schleifen.
• Denthis-Wert vonArray-Methoden.
• Parameter vonObject-Methoden, wieObject.keys().
• Auto-Boxing, wenn eine Eigenschaft auf einen primitiven Wert zugegriffen wird, da Primitive keine Eigenschaften haben.
• Denthis-Wert bei Aufrufen einer nicht-strengen Funktion. Primitive werden eingebunden, währendnull undundefined durch dasglobale Objekt ersetzt werden.

Im Gegensatz zurUmwandlung in primitive Werte ist der Objekterzwingungsprozess selbst in keiner Weise beobachtbar, da er keinen benutzerdefinierten Code wietoString- odervalueOf-Methoden aufruft.

Konstruktor

Object()

Wandelt die Eingabe in ein Objekt um.

Statische Methoden

Object.assign()

Kopiert die Werte aller aufzählbaren eigenen Eigenschaften von einem oder mehreren Quellobjekten auf ein Zielobjekt.

Object.create()

Erstellt ein neues Objekt mit dem angegebenen Prototyp-Objekt und Eigenschaften.

Object.defineProperties()

Fügt einem Objekt die benannten Eigenschaften hinzu, die durch die gegebenen Deskriptoren beschrieben werden.

Object.defineProperty()

Fügt einem Objekt die benannte Eigenschaft hinzu, die durch einen gegebenen Deskriptor beschrieben wird.

Object.entries()

Gibt ein Array mit allen[key, value]-Paaren dereigenen aufzählbaren String-Eigenschaften eines gegebenen Objekts zurück.

Object.freeze()

Friert ein Objekt ein. Anderer Code kann seine Eigenschaften nicht löschen oder ändern.

Object.fromEntries()

Gibt ein neues Objekt von einem iterierbaren[key, value]-Paar zurück. (Dies ist das Gegenteil vonObject.entries).

Object.getOwnPropertyDescriptor()

Gibt einen Eigenschaftsdeskriptor für eine benannte Eigenschaft eines Objekts zurück.

Object.getOwnPropertyDescriptors()

Gibt ein Objekt zurück, das alle eigenen Eigenschaftsdeskriptoren für ein Objekt enthält.

Object.getOwnPropertyNames()

Gibt ein Array mit den Namen allereigenen aufzählbaren und nicht aufzählbaren Eigenschaften eines gegebenen Objekts zurück.

Object.getOwnPropertySymbols()

Gibt ein Array aller Symbol-Eigenschaften zurück, die direkt auf einem gegebenen Objekt gefunden werden.

Object.getPrototypeOf()

Gibt den Prototyp (das interne[[Prototype]]-Eigenschaft) des angegebenen Objekts zurück.

Object.groupBy()

Gruppiert die Elemente eines gegebenen iterierbaren Objekts gemäß den durch einen bereitgestellten Callback-Funktion zurückgegebenen String-Werten. Das zurückgegebene Objekt hat separate Eigenschaften für jede Gruppe, die Arrays mit den Elementen in der Gruppe enthalten.

Object.hasOwn()

Gibttrue zurück, wenn das angegebene Objekt die angegebene Eigenschaft als seineeigene Eigenschaft hat, oderfalse, wenn die Eigenschaft geerbt wird oder nicht existiert.

Object.is()

Vergleicht, ob zwei Werte dasselbe sind. Setzt alleNaN-Werte gleich (was sich vonIsLooselyEqual, das durch== verwendet wird, undIsStrictlyEqual, das durch=== verwendet wird, unterscheidet).

Object.isExtensible()

Bestimmt, ob die Erweiterung eines Objekts zulässig ist.

Object.isFrozen()

Bestimmt, ob ein Objekt eingefroren ist.

Object.isSealed()

Bestimmt, ob ein Objekt versiegelt ist.

Object.keys()

Gibt ein Array mit den Namen allereigenen aufzählbaren String-Eigenschaften eines gegebenen Objekts zurück.

Object.preventExtensions()

Verhindert alle Erweiterungen eines Objekts.

Object.seal()

Verhindert, dass anderer Code Eigenschaften eines Objekts löscht.

Object.setPrototypeOf()

Setzt den Prototyp (die interne[[Prototype]]-Eigenschaft) eines Objekts.

Object.values()

Gibt ein Array mit den Werten zurück, die alleneigenen aufzählbaren String-Eigenschaften eines gegebenen Objekts entsprechen.

Instanzeigenschaften

Diese Eigenschaften sind aufObject.prototype definiert und werden von allenObject-Instanzen geteilt.

Object.prototype.__proto__Veraltet

Zeigt auf das Objekt, das als Prototype verwendet wurde, als das Objekt instanziiert wurde.

Object.prototype.constructor

Die Konstruktorfunktion, die das Instanzobjekt erstellt hat. Für einfacheObject-Instanzen ist der ursprüngliche Wert derObject-Konstruktor. Instanzen anderer Konstruktoren erben jede dieconstructor-Eigenschaft von ihrem jeweiligenConstructor.prototype-Objekt.

Instanzmethoden

Object.prototype.__defineGetter__()Veraltet

Verknüpft eine Funktion mit einer Eigenschaft, die beim Zugriff diese Funktion ausführt und ihren Rückgabewert zurückgibt.

Object.prototype.__defineSetter__()Veraltet

Verknüpft eine Funktion mit einer Eigenschaft, die beim Setzen diese Funktion ausführt, die die Eigenschaft modifiziert.

Object.prototype.__lookupGetter__()Veraltet

Gibt die Funktion zurück, die als Getter an die angegebene Eigenschaft gebunden ist.

Object.prototype.__lookupSetter__()Veraltet

Gibt die Funktion zurück, die als Setter an die angegebene Eigenschaft gebunden ist.

Object.prototype.hasOwnProperty()

Gibt einen Boolean zurück, der angibt, ob ein Objekt die angegebene Eigenschaft als direkte Eigenschaft dieses Objekts enthält und nicht durch die Prototypenkette geerbt wird.

Object.prototype.isPrototypeOf()

Gibt einen Boolean zurück, der angibt, ob das Objekt, auf dem diese Methode aufgerufen wird, in der Prototypenkette des angegebenen Objekts enthalten ist.

Object.prototype.propertyIsEnumerable()

Gibt einen Boolean zurück, der angibt, ob die angegebene Eigenschaft dieenumerable own-Eigenschaft des Objekts ist.

Object.prototype.toLocaleString()

RufttoString() auf.

Object.prototype.toString()

Gibt eine String-Darstellung des Objekts zurück.

Object.prototype.valueOf()

Gibt den primitiven Wert des angegebenen Objekts zurück.

Beispiele

Leere Objekte erstellen

Das folgende Beispiel erstellt leere Objekte mit demnew-Schlüsselwort mit unterschiedlichen Argumenten:

const o1 = new Object();const o2 = new Object(undefined);const o3 = new Object(null);

Verwenden des Object() Konstruktors, um Primitive in ein Objekt ihres jeweiligen Typs zu verwandeln

Sie können denObject()-Konstruktor verwenden, um einen Objekt-Wrapper eines primitiven Werts zu erstellen.

Die folgenden Beispiele erstellen die Variableno1 undo2, dieBoolean undBigInt-Werte speichern:

// Equivalent to const o1 = new Boolean(true)const o1 = new Object(true);// No equivalent because BigInt() can't be called as a constructor,// and calling it as a regular function won't create an objectconst o2 = new Object(1n);

Objekt-Prototypen

Beim Ändern des Verhaltens vorhandenerObject.prototype-Methoden sollten Sie erwägen, Code durch Injizieren Ihres Erweiterungscode vor oder nach der bestehenden Logik auszuführen. Zum Beispiel wird dieser (ungetestete) Code vorkonditionelle eigene Logik ausführen, bevor die eingebaute Logik oder die Erweiterung eines anderen ausgeführt wird.

Beim Modifizieren von Prototypen mit Hooks sollten Siethis und die Argumente (den Aufrufzustand) an das aktuelle Verhalten weitergeben, indem Sieapply() auf die Funktion aufrufen. Dieses Muster kann bei jedem Prototyp verwendet werden, wieNode.prototype,Function.prototype, etc.

const current = Object.prototype.valueOf;// Since my property "-prop-value" is cross-cutting and isn't always// on the same prototype chain, I want to modify Object.prototype:Object.prototype.valueOf = function (...args) {  if (Object.hasOwn(this, "-prop-value")) {    return this["-prop-value"];  }  // It doesn't look like one of my objects, so let's fall back on  // the default behavior by reproducing the current behavior as best we can.  // The apply behaves like "super" in some other languages.  // Even though valueOf() doesn't take arguments, some other hook may.  return current.apply(this, args);};

Mehr über Prototypen können Sie inVererbung und die Prototypenkette lesen.

Spezifikationen

Browser-Kompatibilität

Siehe auch

• Objektinitialisierer
• Prototype Pollution-Angriff