Object.preventExtensions()

obj

Das Objekt, das nicht erweiterbar gemacht werden soll.

Das Objekt, das nicht erweiterbar gemacht wird.

Ein Objekt ist erweiterbar, wenn ihm neue Eigenschaften hinzugefügt werden können. Object.preventExtensions() markiert ein Objekt als nicht mehr erweiterbar, sodass es nie mehr Eigenschaften über die hinaus haben wird, die es zum Zeitpunkt der Markierung als nicht erweiterbar hatte. Beachten Sie, dass die Eigenschaften eines nicht erweiterbaren Objekts im Allgemeinen immer noch gelöscht werden können. Der Versuch, einem nicht erweiterbaren Objekt neue Eigenschaften hinzuzufügen, schlägt fehl, entweder stillschweigend oder, im Strict-Modus, wird ein TypeError ausgelöst.

Im Gegensatz zu Object.seal() und Object.freeze() ruft Object.preventExtensions() ein intrinsisches JavaScript-Verhalten auf und kann nicht durch eine Kombination mehrerer anderer Operationen ersetzt werden. Es hat auch sein Reflect-Gegenstück (das nur für intrinsische Operationen existiert), Reflect.preventExtensions().

Object.preventExtensions() verhindert nur das Hinzufügen eigener Eigenschaften. Eigenschaften können weiterhin zum Prototyp-Objekt hinzugefügt werden.

Diese Methode macht das [[Prototype]] des Ziels unveränderlich; jede [[Prototype]]-Neuzuweisung wird einen TypeError auslösen. Dieses Verhalten ist spezifisch für die interne [[Prototype]]-Eigenschaft; andere Eigenschaften des Zielobjekts bleiben veränderlich.

Es gibt keine Möglichkeit, ein Objekt wieder erweiterbar zu machen, nachdem es nicht erweiterbar gemacht wurde.

// Object.preventExtensions returns the object
// being made non-extensible.
const obj = {};
const obj2 = Object.preventExtensions(obj);
obj === obj2; // true

// Objects are extensible by default.
const empty = {};
Object.isExtensible(empty); // true

// They can be made un-extensible
Object.preventExtensions(empty);
Object.isExtensible(empty); // false

// Object.defineProperty throws when adding
// a new property to a non-extensible object.
const nonExtensible = { removable: true };
Object.preventExtensions(nonExtensible);
Object.defineProperty(nonExtensible, "new", {
  value: 8675309,
}); // throws a TypeError

// In strict mode, attempting to add new properties
// to a non-extensible object throws a TypeError.
function fail() {
  "use strict";
  // throws a TypeError
  nonExtensible.newProperty = "FAIL";
}
fail();

Der Prototyp eines nicht erweiterbaren Objekts ist unveränderlich:

const fixed = Object.preventExtensions({});
// throws a 'TypeError'.
fixed.__proto__ = { oh: "hai" };

In ES5 führt ein Argument, das kein Objekt ist (ein primitiver Wert), zu einem TypeError. In ES2015 wird ein Argument, das kein Objekt ist, unverändert zurückgegeben, ohne dass Fehler auftreten, da primitive Werte per Definition bereits unveränderlich sind.

Object.preventExtensions(1);
// TypeError: 1 is not an object (ES5 code)

Object.preventExtensions(1);
// 1                             (ES2015 code)

• Object.isExtensible()
• Object.seal()
• Object.isSealed()
• Object.freeze()
• Object.isFrozen()
• Reflect.preventExtensions()