Object

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

Änderungen am Object.prototype Objekt werden durch Prototypverkettung von allen Objekten wahrgenommen, es sei denn, die betroffenen Eigenschaften und Methoden werden weiter unten in der Prototypkette überschrieben. Dies bietet eine sehr leistungsfähige, aber 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 einen unveränderlichen Prototyp hat — der Prototyp von Object.prototype ist immer null und nicht veränderbar.

Sie sollten vermeiden, Methoden von Object.prototype direkt von der Instanz aufzurufen, insbesondere solche Methoden, die nicht polymorph sind (d.h. nur das anfängliche Verhalten macht Sinn und kein abgeleitetes Objekt könnte es sinnvoll überschreiben). Alle Objekte, die von Object.prototype abstammen, können eine benutzerdefinierte eigene Eigenschaft definieren, die denselben Namen hat, aber mit völlig anderen Semantiken als erwartet. Darüber hinaus werden diese Eigenschaften nicht von null-Prototyp-Objekten geerbt. Alle modernen JavaScript-Utilities zum Arbeiten mit Objekten sind statisch. Genauer gesagt:

• valueOf(), toString(), und toLocaleString() sind polymorph, und Sie sollten erwarten, dass das Objekt seine eigene Implementierung mit sinnvollen Verhaltensweisen definiert, sodass Sie sie als Instanzmethoden aufrufen können. valueOf() und toString() werden jedoch normalerweise implizit durch Typkonvertierung 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 Object.getPrototypeOf() und Object.setPrototypeOf() Alternativen sind statische Methoden.
• Die Methoden propertyIsEnumerable() und hasOwnProperty() können durch die statischen Methoden Object.getOwnPropertyDescriptor() bzw. Object.hasOwn() ersetzt werden.
• Die Methode isPrototypeOf() kann normalerweise durch instanceof ersetzt werden, wenn Sie die prototype Eigenschaft eines Konstruktors überprüfen.

Falls es keine semantisch äquivalente statische Methode gibt, oder wenn Sie die Object.prototype Methode wirklich 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 produziert.

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()). Dazu muss der delete Operator verwendet werden.

Fast alle Objekte in JavaScript erben letztlich von Object.prototype (siehe Inheritance und die Prototypenkette). Sie können jedoch null-Prototyp-Objekte erstellen, indem Sie Object.create(null) verwenden oder die Objekt Initialisierung Syntax mit __proto__: null (Hinweis: Der __proto__ Schlüssel in Objektliteralen unterscheidet sich von der veralteten Object.prototype.__proto__ Eigenschaft). Sie können auch den Prototyp eines bestehenden Objekts in null ändern, indem Sie Object.setPrototypeOf(obj, null) aufrufen.

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

Ein Objekt mit null Prototyp kann sich unerwartet verhalten, da es keine Objektmethoden von Object.prototype erbt. Dies ist besonders beim Debugging der Fall, da übliche Objekt-Eigenschaft-Umwandlungs-/Erkennungs-Utility-Funktionen möglicherweise Fehler erzeugen oder Informationen verlieren (insbesondere wenn stille Fehlerfallen verwendet werden, die Fehler ignorieren).

Zum Beispiel macht das Fehlen von Object.prototype.toString() oft das Debuggen unnachvollziehbar:

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

Auch andere Methoden werden 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() im Prototyp des Objekts ist, ist die toString() Methode hier eine eigene Eigenschaft von nullProtoObj. Dies liegt daran, dass nullProtoObj keinen (null) Prototyp hat.

Sie können ein null-Prototyp-Objekt auch wieder in ein gewöhnliches Objekt zurückverwandeln, indem Sie Object.setPrototypeOf(nullProtoObj, Object.prototype) verwenden.

In der Praxis werden Objekte mit null Prototyp normalerweise als günstiger Ersatz für Maps verwendet. Das Vorhandensein von Object.prototype Eigenschaften wird einige Fehler 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 zu den Funktionen hasPerson und getAge hinzuzufügen:

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 Ergänzung einer Methode vorsichtig erfolgen, da sie mit den anderen als Daten gespeicherten Schlüssel-Wert-Paaren verwechselt werden kann.

Das Verhindern, dass Ihr Objekt von Object.prototype erbt, verhindert auch Angriffe durch Prototypverschmutzung. Wenn ein bösartiges Skript eine Eigenschaft zu Object.prototype hinzufügt, wird sie in jedem Objekt in Ihrem Programm zugänglich sein, außer in 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 eingebaute APIs, die null-Prototyp-Objekte erzeugen, insbesondere diejenigen, die Objekte als Ad-hoc-Schlüssel-Wert-Sammlungen verwenden. Zum Beispiel:

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

Der Begriff "null-Prototyp-Objekt" bezieht sich oft auch auf jedes Objekt ohne Object.prototype in seiner Prototypkette. Solche Objekte können mit extends null erstellt werden, wenn Klassen verwendet werden.

Viele eingebaute Operationen, die Objekte erwarten, wandeln ihre Argumente zuerst in Objekte um. Die Operation kann wie folgt zusammengefasst werden:

• Objekte werden unverändert zurückgegeben.
• undefined und null werfen einen TypeError.
• Number, String, Boolean, Symbol, BigInt Primitive werden in ihre entsprechenden Objektwrapper umgewandelt.

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

• Object.prototype.valueOf(): Object.prototype.valueOf.call(x) führt genau die oben erläuterten Schritte der Objektkoerzierung durch, um x umzuwandeln.
• Die Object() Funktion: Object(x) verwendet denselben Algorithmus, um x zu konvertieren, außer dass undefined und null keinen TypeError werfen, sondern ein einfaches Objekt zurückgeben.

Orte, die Objektkoerzierung verwenden, sind:

• Der object Parameter von for...in Schleifen.
• Der this Wert von Array Methoden.
• Parameter von Object Methoden wie Object.keys().
• Automatisches Boxen, wenn eine Eigenschaft auf einem primitiven Wert zugegriffen wird, da Primitive keine Eigenschaften haben.
• Der this Wert beim Aufrufen einer nicht-strengen Funktion. Primitive werden ge-box-t, während null und undefined durch das globale Objekt ersetzt werden.

Im Gegensatz zur Umwandlung in Primitive ist der Prozess der Objektkoerzierung 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 Prototypobjekt und Eigenschaften.

Object.defineProperties()

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

Object.defineProperty()

Fügt einer Eigenschaft, die durch einen gegebenen Deskriptor beschrieben wird, 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 von [key, value] Paaren zurück. (Dies ist das Gegenteil von Object.entries).

Object.getOwnPropertyDescriptor()

Gibt eine Eigenschaftsbeschreibung 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-aufruftbaren Eigenschaften des gegebenen Objekts enthält.

Object.getOwnPropertySymbols()

Gibt ein Array aller auf einem bestimmten Objekt gefundenen Symboleigenschaften zurück.

Object.getPrototypeOf()

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

Object.groupBy()

Gruppiert die Elemente eines gegebenen Iterables gemäß den von einer 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()

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

Object.is()

Vergleicht, ob zwei Werte derselbe Wert sind. Setzt alle NaN Werte gleich (was sich von sowohl IsLooselyEqual, verwendet von ==, als auch IsStrictlyEqual, verwendet von ===, 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 (seine 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 jeweils die constructor Eigenschaft von ihrem jeweiligen Constructor.prototype Objekt.

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 vererbt wurde.

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 ist.

Object.prototype.propertyIsEnumerable()

Gibt einen boolean 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 String-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 unterschiedlichen Argumenten:

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

Sie können den Object() Konstruktor verwenden, um eine Objektwrapper eines primitiven Werts zu erstellen.

Die folgenden Beispiele erstellen die Variablen o1 und o2, 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);

Beim Ändern des Verhaltens vorhandener Object.prototype Methoden sollten Sie erwägen, Code durch Einfügen vor oder nach der bestehenden Logik zu injizieren. Zum Beispiel wird dieser (nicht getestete) Code benutzerdefinierte Logik vor der eingebauten Logik oder jemand anderes Erweiterung ausgeführen.

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, 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);
};

Sie können mehr über Prototypen in Inheritance und die Prototypenkette lesen.

• Objekt Initialisierung