CKTIS / JavaScript
Function.prototype a syntax konštruktora triedy
Rozlíšte prototypový reťazec funkcie od vlastnosti `.prototype` používanej pre inštancie a zistite, ako pri dedení spolu súvisia `new`, `constructor` a `super()`.
Verzia: 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 je vstavaný funkčný objekt, z ktorého funkcie dedia metódy ako call, apply a bind. Je priamym prototypom bežnej funkcie deklarovanej pomocou function a triedy bez extends. Volanie Function.prototype() vráti undefined, no new Function.prototype() vyvolá TypeError.
C.prototype je niečo iné: je to vlastná vlastnosť bežnej konštruktorovej funkcie alebo triedy C. Ak je jej hodnotou objekt, new C(...) ho bežne použije ako prototyp inštancie. Toto prepojenie overíte cez Object.getPrototypeOf(instance). Konštruktor však môže výslovne vrátiť iný objekt. Pridaním .prototype k šípkovej funkcii nezískate možnosť použiť ju s new.
Vnútri class inicializuje constructor(...) { ... } inštanciu, zvyčajne priradením hodnôt do vlastností cez this. Verejné metódy inštancií, napríklad read(), sú na C.prototype, metódy static na C. Na rozdiel od bežnej funkcie priame volanie triedy ako C(...) vyvolá TypeError. Nahradením .prototype bežnej funkcie sa nezmení prototyp existujúcich inštancií. V triede do tejto vlastnosti nemožno zapisovať, no samotný objekt prototypu sa stále dá upravovať.
V class Derived extends Base dedí Derived z Base a Derived.prototype z Base.prototype. V explicitnom konštruktore odvodenej triedy zavolajte super(...) pred použitím this; skoršie použitie vyvolá ReferenceError. Ak priamo vrátite objekt bez použitia this, môžete super() vynechať. Ak vynecháte celý konštruktor odvodenej triedy, predvolený konštruktor posunie argumenty ďalej.
Príklady
{
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);
}
}Výsledok
true true true true Ada Lin true false TypeError
Spustite celý blok v konzole s podporou syntaxe `class`. Prvé dva riadky porovnávajú prototypy konštruktorov a inštancií; posledný ukazuje názov chyby nezávisle od znenia jej hlásenia.
Súvisiace lekcie
- JavaScript · Lekcia 32 · Pokročilá · Verzia: 4