CKTIS / JavaScript
Function.prototype en de syntaxis van klasseconstructors
Onderscheid de prototypeketen van een functie van de eigenschap `.prototype` voor instanties en zie hoe `new`, `constructor` en `super()` bij overerving samenwerken.
Versie: ECMAScript 2024 and the current web platform; runtime support varies
Syntax
function C(value) {
this.value = value;
}
C.prototype.read = function () {
return this.value;
};
const instance = new C(1);
Function.prototype
Object.getPrototypeOf(C)
C.prototype
Object.getPrototypeOf(instance)
class Base {
constructor(value) {
this.value = value;
}
read() {
return this.value;
}
}
class Derived extends Base {
constructor(value) {
super(value);
this.ready = true;
}
}
const derived = new Derived(2);Function.prototype is het ingebouwde functieobject waarvan functies methoden zoals call, apply en bind erven. Het is het directe prototype van een gewone functie die je met function declareert en van een klasse zonder extends. De aanroep Function.prototype() geeft undefined terug, maar new Function.prototype() veroorzaakt een TypeError.
C.prototype is iets anders: het is een eigen eigenschap van een gewone constructorfunctie of klasse C. Als de waarde een object is, gebruikt new C(...) dit normaal als prototype van de instantie. Controleer die koppeling met Object.getPrototypeOf(instance). Een constructor kan in plaats daarvan expliciet een ander object teruggeven. Door .prototype aan een pijlfunctie toe te voegen, maak je die niet bruikbaar met new.
Binnen een class initialiseert constructor(...) { ... } de instantie, meestal door eigenschappen via this in te stellen. Publieke instantiemethoden zoals read() staan op C.prototype; static-methoden staan op C. Anders dan bij een gewone functie veroorzaakt een directe aanroep van een klasse met C(...) een TypeError. Vervanging van .prototype op een gewone functie verandert het prototype van bestaande instanties niet. Bij een klasse is de eigenschap niet schrijfbaar, maar het prototypeobject zelf kun je nog wijzigen.
In class Derived extends Base erft Derived van Base en Derived.prototype van Base.prototype. Roep in een expliciete afgeleide constructor super(...) aan voordat je this gebruikt; eerder gebruik veroorzaakt een ReferenceError. Geef je rechtstreeks een object terug zonder this te gebruiken, dan kun je super() overslaan. Laat je de afgeleide constructor helemaal weg, dan geeft de standaardconstructor de argumenten door.
Voorbeelden
{
function Legacy(name) {
this.name = name;
}
Legacy.prototype.read = function () {
return this.name;
};
class Modern {
constructor(name) {
this.name = name;
}
read() {
return this.name;
}
}
const a = new Legacy('Ada');
const b = new Modern('Lin');
const prototypeOf = Object.getPrototypeOf;
const descriptor = Object.getOwnPropertyDescriptor;
console.log(`${prototypeOf(Legacy) === Function.prototype} ${prototypeOf(Modern) === Function.prototype}`);
console.log(`${prototypeOf(a) === Legacy.prototype} ${prototypeOf(b) === Modern.prototype}`);
console.log(`${a.read()} ${b.read()}`);
console.log(`${descriptor(Legacy, 'prototype').writable} ${descriptor(Modern, 'prototype').writable}`);
try {
Modern('Lin');
} catch (error) {
console.log(error.name);
}
}Resultaat
true true true true Ada Lin true false TypeError
Voer het hele blok uit in een console die `class`-syntaxis ondersteunt. De eerste twee regels vergelijken de prototypes van de constructors en de instanties; de laatste toont de foutnaam zonder af te hangen van de foutmelding.
Gerelateerde lessen
- JavaScript · Les 32 · Gevorderd · Versie: 4