Object.setPrototypeOf()

obj

Das Objekt, dessen Prototyp gesetzt werden soll.

prototype

Das neue Prototyp-Objekt des Objekts (ein Objekt oder null).

Das angegebene Objekt.

TypeError

Wird in einem der folgenden Fälle ausgelöst:

• Der obj-Parameter ist undefined oder null.
• Der obj-Parameter ist nicht erweiterbar oder er ist ein unveränderliches Prototyp-Objekt, wie Object.prototype oder window. Ein Fehler wird jedoch nicht ausgelöst, wenn das neue Prototyp-Objekt denselben Wert hat wie das ursprüngliche Prototyp-Objekt von obj.
• Der prototype-Parameter ist kein Objekt oder null.

Object.setPrototypeOf() wird allgemein als die richtige Methode angesehen, um das Prototyp eines Objekts zu setzen. Sie sollten es immer dem veralteten Object.prototype.__proto__-Accessor vorziehen.

Wenn der obj-Parameter kein Objekt ist (z.B. Zahl, String, etc.), macht diese Methode nichts — ohne es zu einem Objekt zu erzwingen oder zu versuchen, sein Prototyp zu setzen — und gibt obj direkt als primitiven Wert zurück. Wenn prototype denselben Wert wie der Prototyp von obj hat, wird obj direkt zurückgegeben, ohne einen TypeError zu verursachen, selbst wenn obj ein unveränderliches Prototyp hat.

Aufgrund von Sicherheitsbedenken gibt es bestimmte eingebaut Objekte, die so gestaltet sind, dass sie ein unveränderliches Prototyp haben. Dies verhindert Angriffe zur Prototyp-Verunreinigung, insbesondere bei Proxy-bezogenen. Die Hauptsprache spezifiziert nur Object.prototype als ein unveränderliches Prototyp-Objekt, dessen Prototyp immer null ist. In Browsern sind window und location zwei weitere sehr häufige Beispiele.

Object.isExtensible(Object.prototype); // true; you can add more properties
Object.setPrototypeOf(Object.prototype, {}); // TypeError: Immutable prototype object '#<Object>' cannot have their prototype set
Object.setPrototypeOf(Object.prototype, null); // No error; the prototype of `Object.prototype` is already `null`

Vererbung in JS unter Verwendung von Klassen.

class Human {}
class SuperHero extends Human {}

const superMan = new SuperHero();

Wenn wir jedoch Unterklassen ohne die Verwendung von class implementieren möchten, können wir Folgendes tun:

function Human(name, level) {
  this.name = name;
  this.level = level;
}

function SuperHero(name, level) {
  Human.call(this, name, level);
}

Object.setPrototypeOf(SuperHero.prototype, Human.prototype);

// Set the `[[Prototype]]` of `SuperHero.prototype`
// to `Human.prototype`
// To set the prototypal inheritance chain

Human.prototype.speak = function () {
  return `${this.name} says hello.`;
};

SuperHero.prototype.fly = function () {
  return `${this.name} is flying.`;
};

const superMan = new SuperHero("Clark Kent", 1);

console.log(superMan.fly());
console.log(superMan.speak());

Die Ähnlichkeit zwischen klassischer Vererbung (mit Klassen) und pseudoklassischer Vererbung (mit dem prototype-Property der Konstruktoren), wie oben beschrieben, wird in Inheritance chains erwähnt.

Da das prototype-Property von Funktionskonstruktoren beschreibbar ist, können Sie es einem neuen Objekt, das mit Object.create() erstellt wurde, neu zuweisen, um die gleiche Vererbungskette zu erreichen. Es gibt jedoch einige Dinge, auf die beim Verwenden von create() geachtet werden muss, wie etwa das erneute Hinzufügen der constructor-Eigenschaft.

Im folgenden Beispiel, in dem auch Klassen verwendet werden, wird SuperHero so erstellt, dass es von Human erbt, ohne extends zu verwenden, indem statt dessen setPrototypeOf() verwendet wird.

class Human {}
class SuperHero {}

// Set the instance properties
Object.setPrototypeOf(SuperHero.prototype, Human.prototype);

// Hook up the static properties
Object.setPrototypeOf(SuperHero, Human);

const superMan = new SuperHero();

Das Subclassing ohne extends wird in ES-6 subclassing erwähnt.

• Polyfill von Object.setPrototypeOf in core-js
• Reflect.setPrototypeOf()
• Object.prototype.isPrototypeOf()
• Object.getPrototypeOf()
• Object.prototype.__proto__
• Inheritance chain
• ES6 In Depth: Subclassing auf hacks.mozilla.org (2015)