Object

Nahezu alle Objekte in JavaScript sind Instanzen von Object; ein typisches Objekt erbt Eigenschaften (einschließlich Methoden) von Object.prototype, obwohl diese Eigenschaften möglicherweise überschattet (d.h. überschrieben) werden. Die einzigen Objekte, die nicht von Object.prototype erben, sind solche mit null-Prototyp oder von anderen null-Prototyp-Objekten abstammen.

Änderungen am Object.prototype-Objekt sind bei allen Objekten durch Prototypenverkettung sichtbar, es sei denn, die Eigenschaften und Methoden, die von diesen Änderungen betroffen sind, werden weiter entlang der Prototypkette überschrieben. Dies bietet eine sehr mächtige, wenn auch potenziell gefährliche Möglichkeit, das Verhalten von Objekten zu überschreiben oder zu erweitern. Um es sicherer zu machen, ist Object.prototype das einzige Objekt in der Kern-JavaScript-Sprache, das unveränderlichen Prototypen hat — der Prototyp von Object.prototype ist immer null und nicht veränderbar.

Sie sollten vermeiden, eine der Object.prototype-Methoden direkt aus der Instanz aufzurufen, insbesondere solche, die nicht polymorph gestaltet sind (d.h. nur das anfängliche Verhalten macht Sinn, und kein abgeleitetes Objekt könnte es sinnvoll überschreiben). Alle von Object.prototype abgeleiteten Objekte können eine eigene benutzerdefinierte Eigenschaft mit demselben Namen definieren, aber mit völlig anderen Semantiken als erwartet. Außerdem werden diese Eigenschaften nicht von null-Prototyp-Objekten geerbt. Alle modernen JavaScript-Dienstprogramme zur Arbeit mit Objekten sind statisch. Genauer gesagt:

• valueOf(), toString() und toLocaleString() sind dafür gedacht, polymorph zu sein, und Sie sollten erwarten, dass das Objekt seine eigene Implementierung mit sinnvollen Verhaltensweisen definiert, so dass Sie sie als Instanzmethoden aufrufen können. Allerdings werden valueOf() und toString() normalerweise implizit durch Typumwandlung aufgerufen und Sie müssen sie nicht selbst in Ihrem Code aufrufen.
• __defineGetter__(), __defineSetter__(), __lookupGetter__() und __lookupSetter__() sind veraltet und sollten nicht verwendet werden. Verwenden Sie stattdessen die statischen Alternativen Object.defineProperty() und Object.getOwnPropertyDescriptor().
• Die __proto__-Eigenschaft ist veraltet und sollte nicht verwendet werden. Die Alternativen Object.getPrototypeOf() und Object.setPrototypeOf() sind statische Methoden.
• Die Methoden propertyIsEnumerable() und hasOwnProperty() können durch die statischen Methoden Object.getOwnPropertyDescriptor() und Object.hasOwn() ersetzt werden.
• Die Methode isPrototypeOf() kann normalerweise durch instanceof ersetzt werden, wenn Sie die prototype-Eigenschaft eines Konstruktors überprüfen.

Falls keine semantisch äquivalente statische Methode existiert oder Sie wirklich die Object.prototype-Methode verwenden möchten, sollten Sie die Object.prototype-Methode direkt mit call() auf Ihrem Zielobjekt aufrufen, um zu verhindern, dass das Objekt eine überschreibende Eigenschaft hat, 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 result
Object.prototype.propertyIsEnumerable.call(obj, "foo"); // true; expected result

Es gibt keine Methode in einem Objekt selbst, um seine eigenen Eigenschaften zu löschen (wie Map.prototype.delete()). Um dies zu tun, muss der Operator delete verwendet werden.

Fast alle Objekte in JavaScript erben letztendlich von Object.prototype (siehe Vererbung und die Prototypenkette). Sie können jedoch null-Prototyp-Objekte mit Object.create(null) oder der Objekt-Initialisierer-Syntax mit __proto__: null erstellen (Hinweis: der __proto__-Schlüssel in Objekt-Literalen unterscheidet sich von der veralteten Object.prototype.__proto__-Eigenschaft). Sie können den Prototyp eines vorhandenen Objekts auch mit einem Aufruf von Object.setPrototypeOf(obj, null) in null ändern.

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

Ein Objekt mit einem null-Prototyp kann sich auf unerwartete Weise verhalten, da es keine Objektmethoden von Object.prototype erbt. Dies gilt besonders beim Debuggen, da gewöhnliche Objekt-Eigenschaftsumwandlungs-/Erkennungs-Dienstprogramme Fehlermeldungen erzeugen oder Informationen verlieren können (insbesondere bei Verwendung stiller Fehlerrückhalter, die Fehler ignorieren).

Zum Beispiel macht das Fehlen von Object.prototype.toString() das Debuggen oft unrückverfolgbar:

const normalObj = {}; // create a normal object
const nullProtoObj = Object.create(null); // create an object with "null" prototype

console.log(`normalObj is: ${normalObj}`); // shows "normalObj is: [object Object]"
console.log(`nullProtoObj is: ${nullProtoObj}`); // throws error: Cannot convert object to primitive value

alert(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 function

normalObj.hasOwnProperty("p"); // shows "true"
nullProtoObj.hasOwnProperty("p"); // throws error: nullProtoObj.hasOwnProperty is not a function

normalObj.constructor; // shows "Object() { [native code] }"
nullProtoObj.constructor; // shows "undefined"

Wir können die toString-Methode dem Null-Prototyp-Objekt zurückgeben, indem wir ihm eine zuweisen:

nullProtoObj.toString = Object.prototype.toString; // since new object lacks toString, add the original generic one back

console.log(nullProtoObj.toString()); // shows "[object Object]"
console.log(`nullProtoObj is: ${nullProtoObj}`); // shows "nullProtoObj is: [object Object]"

Im Gegensatz zu normalen Objekten, bei denen toString() auf dem Prototyp des Objekts liegt, ist hier die toString()-Methode eine eigene Eigenschaft von nullProtoObj. Dies liegt daran, dass nullProtoObj keinen (null) Prototyp hat.

Sie können auch ein Null-Prototyp-Objekt wieder in ein gewöhnliches Objekt umwandeln, indem Sie Object.setPrototypeOf(nullProtoObj, Object.prototype) aufrufen.

In der Praxis werden Objekte mit null-Prototyp häufig als günstiger Ersatz für Maps verwendet. Das Vorhandensein von Object.prototype-Eigenschaften kann einige Probleme verursachen:

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

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

function getAge(name) {
  return ages[name];
}

hasPerson("hasOwnProperty"); // true
getAge("toString"); // [Function: toString]

Die Verwendung eines Null-Prototyp-Objekts beseitigt diese Gefahr, ohne zu viel Komplexität in die hasPerson- und getAge-Funktionen einzuführen:

const ages = Object.create(null, {
  alice: { value: 18, enumerable: true },
  bob: { value: 27, enumerable: true },
});

hasPerson("hasOwnProperty"); // false
getAge("toString"); // undefined

In einem solchen Fall sollte die Hinzufügung von Methoden vorsichtig erfolgen, da sie mit anderen, als Daten gespeicherten Schlüssel-Wert-Paaren verwechselt werden können.

Wenn Ihr Objekt nicht von Object.prototype erbt, verhindert dies auch Angriffe durch Prototypenverschmutzung. Wenn ein bösartiges Skript eine Eigenschaft zu Object.prototype hinzufügt, ist diese Eigenschaft in jedem Objekt in Ihrem Programm zugänglich, außer bei Objekten, die einen Null-Prototyp haben.

const user = {};

// A malicious script:
Object.prototype.authenticated = true;

// Unexpectedly allowing unauthenticated user to pass through
if (user.authenticated) {
  // access confidential data
}

JavaScript hat auch integrierte APIs, die null-Prototyp-Objekte erzeugen, insbesondere solche, die Objekte als aus der Not geborene Schlüssel-Wert-Sammlungen verwenden. Zum Beispiel:

• Der Rückgabewert von Object.groupBy()
• Die groups- und indices.groups-Eigenschaften des Ergebnisses von RegExp.prototype.exec()
• Array.prototype[Symbol.unscopables] (alle [Symbol.unscopables]-Objekte sollten einen null-Prototyp haben)
• import.meta
• Modul-Namespace-Objekte, die durch import * as ns from "module"; oder import() erhalten werden

Der Begriff "null-Prototyp-Objekt" schließt oft auch jedes Objekt ein, dessen Prototypenkette Object.prototype nicht enthält. Solche Objekte können erstellt werden mit extends null, wenn Sie Klassen verwenden.

Viele eingebaute Operationen, die Objekte erwarten, wandeln ihre Argumente zuerst in Objekte um. Die Operation lässt sich wie folgt zusammenfassen:

• Objekte werden unverändert zurückgegeben.
• undefined und null werfen einen TypeError.
• Number, String, Boolean, Symbol, BigInt-Primitiven werden in ihre entsprechenden Objekt-Wrapper gewickelt.

Es gibt zwei Möglichkeiten, um in JavaScript fast den gleichen Effekt zu erzielen.

• Object.prototype.valueOf(): Object.prototype.valueOf.call(x) führt genau die oben erklärten Objektumwandlungsschritte aus, um x zu konvertieren.
• Die Object()-Funktion: Object(x) verwendet denselben Algorithmus zur Umwandlung von x, außer dass undefined und null keinen TypeError werfen, sondern ein einfaches Objekt zurückgeben.

Orte, die Objektumwandlung verwenden, umfassen:

• Der object-Parameter von for...in-Schleifen.
• Der this-Wert von Array-Methoden.
• Parameter von Object-Methoden wie Object.keys().
• Auto-Boxing, wenn eine Eigenschaft auf einem Primärwert zugegriffen wird, da Primitiven keine Eigenschaften haben.
• Der this-Wert beim Aufruf einer nicht-strikten Funktion. Primitiven werden verpackt, während null und undefined durch das globale Objekt ersetzt werden.

Im Gegensatz zur Umwandlung in Primitive ist der Objektumwandlungsprozess selbst in keiner Weise beobachtbar, da er keinen benutzerdefinierten Code wie toString- oder valueOf-Methoden aufruft.

Object()

Wandelt die Eingabe in ein Objekt um.

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 die benannten Eigenschaften, wie durch die angegebenen Deskriptoren beschrieben, zu einem Objekt hinzu.

Object.defineProperty()

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

Object.entries()

Gibt ein Array zurück, das alle [key, value]-Paare der eigenen aufzählbaren String-Eigenschaften eines gegebenen Objekts enthält.

Object.freeze()

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

Object.fromEntries()

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

Object.getOwnPropertyDescriptor()

Gibt einen Eigenschaftsdeskriptor für eine benannte Eigenschaft auf einem Objekt zurück.

Object.getOwnPropertyDescriptors()

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

Object.getOwnPropertyNames()

Gibt ein Array zurück, das die Namen aller eigenen aufzählbaren und nicht-auzählbaren Eigenschaften des gegebenen Objekts enthält.

Object.getOwnPropertySymbols()

Gibt ein Array aller direkt auf einem gegebenen Objekt gefundenen Symbol-Eigenschaften zurück.

Object.getPrototypeOf()

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

Object.groupBy()

Gruppiert die Elemente eines gegebenen iterierbaren Objekts nach den String-Werten, die von einer bereitgestellten Rückruffunktion zurückgegeben werden. Das zurückgegebene Objekt hat separate Eigenschaften für jede Gruppe, die Arrays mit den Elementen in der Gruppe enthalten.

Object.hasOwn()

Gibt true zurück, wenn das angegebene Objekt die angegebene Eigenschaft als seine eigene Eigenschaft hat, oder false, wenn die Eigenschaft geerbt oder nicht vorhanden ist.

Object.is()

Vergleicht, ob zwei Werte derselbe Wert sind. Vergleicht alle NaN-Werte (was sich von sowohl IsLooselyEqual verwendet durch == als auch IsStrictlyEqual verwendet durch === unterscheidet).

Object.isExtensible()

Bestimmt, ob das Erweitern eines Objekts erlaubt ist.

Object.isFrozen()

Bestimmt, ob ein Objekt eingefroren wurde.

Object.isSealed()

Bestimmt, ob ein Objekt versiegelt ist.

Object.keys()

Gibt ein Array zurück, das die Namen aller eigenen aufzählbaren String-Eigenschaften des gegebenen Objekts enthält.

Object.preventExtensions()

Verhindert jegliche Erweiterungen eines Objekts.

Object.seal()

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

Object.setPrototypeOf()

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

Object.values()

Gibt ein Array zurück, das die Werte enthält, die allen eigenen aufzählbaren String-Eigenschaften eines gegebenen Objekts entsprechen.

Diese Eigenschaften sind in Object.prototype definiert und werden von allen Object-Instanzen geteilt.

Object.prototype.__proto__ Veraltet

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

Object.prototype.constructor

Die Konstruktorfunktion, die das Instanzobjekt erstellt hat. Für einfache Object-Instanzen ist der Anfangswert der Object-Konstruktor. Instanzen anderer Konstruktoren erben jede die constructor-Eigenschaft von ihrem jeweiligen Constructor.prototype-Objekt.

Object.prototype.__defineGetter__() Veraltet

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

Object.prototype.__defineSetter__() Veraltet

Verknüpft eine Funktion mit einer Eigenschaft, die, wenn sie gesetzt wird, diese Funktion ausführt, die die Eigenschaft verändert.

Object.prototype.__lookupGetter__() Veraltet

Gibt die als Getter an die angegebene Eigenschaft gebundene Funktion zurück.

Object.prototype.__lookupSetter__() Veraltet

Gibt die als Setter an die angegebene Eigenschaft gebundene Funktion zurück.

Object.prototype.hasOwnProperty()

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

Object.prototype.isPrototypeOf()

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

Object.prototype.propertyIsEnumerable()

Gibt einen booleschen Wert zurück, der angibt, ob die angegebene Eigenschaft die aufzählbare eigene Eigenschaft des Objekts ist.

Object.prototype.toLocaleString()

Ruft toString() auf.

Object.prototype.toString()

Gibt eine Zeichenfolgen-Darstellung des Objekts zurück.

Object.prototype.valueOf()

Gibt den primitiven Wert des angegebenen Objekts zurück.

Das folgende Beispiel erstellt leere Objekte mit dem new-Schlüsselwort mit verschiedenen Argumenten:

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

Sie können den Object()-Konstruktor verwenden, um ein Objekt-Wrapper eines primitiven Wertes zu erstellen.

Die folgenden Beispiele erstellen Variablen o1 und o2, die Objekte sind, die Boolean- und BigInt-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 object
const o2 = new Object(1n);

Wenn Sie das Verhalten bestehender Object.prototype-Methoden ändern, sollten Sie das Einspritzen von Code in Betracht ziehen, indem Sie Ihre Erweiterung vor oder nach der bestehenden Logik ausführen. Zum Beispiel führt dieser (ungetestete) Code benutzerdefinierte Logik bedingt vor der eingebauten Logik oder der Erweiterung von jemand anderem aus.

Beim Modifizieren von Prototypen mit Hooks übergeben Sie this und die Argumente (den Aufrufzustand) an das aktuelle Verhalten, indem Sie apply() auf die Funktion aufrufen. Dieses Muster kann für jeden Prototyp verwendet werden, wie z.B. Node.prototype, Function.prototype, usw.

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 zu Prototypen können Sie im Artikel Vererbung und die Prototypenkette lesen.

• Objekt-Initialisierer