CKTIS / JavaScript
Function.prototype et la syntaxe des constructeurs de classe
Distinguez la chaîne de prototypes d’une fonction de la propriété `.prototype` utilisée pour les instances, et voyez le rôle de `new`, `constructor` et `super()` dans l’héritage.
Version : ECMAScript 2024 and the current web platform; runtime support varies
Syntaxe
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 est l’objet fonction intégré dont les fonctions héritent des méthodes telles que call, apply et bind. C’est le prototype direct d’une fonction ordinaire déclarée avec function et d’une classe sans extends. L’appel Function.prototype() renvoie undefined, mais new Function.prototype() lève une TypeError.
C.prototype est autre chose : c’est une propriété propre à une fonction constructeur ordinaire ou à une classe C. Si sa valeur est un objet, new C(...) l’utilise normalement comme prototype de l’instance. Vérifiez ce lien avec Object.getPrototypeOf(instance). Un constructeur peut toutefois renvoyer explicitement un autre objet. Ajouter .prototype à une fonction fléchée ne permet pas de l’utiliser avec new.
Dans une class, constructor(...) { ... } initialise l’instance, généralement par des affectations à this. Les méthodes d’instance publiques telles que read() sont définies sur C.prototype, les méthodes static sur C. Contrairement à l’appel d’une fonction ordinaire, l’appel direct d’une classe avec C(...) lève une TypeError. Remplacer .prototype sur une fonction ordinaire ne change pas le prototype des instances existantes. Pour une classe, cette propriété n’est pas accessible en écriture, mais l’objet prototype lui-même reste modifiable.
Dans class Derived extends Base, Derived hérite de Base et Derived.prototype de Base.prototype. Dans un constructeur dérivé explicite, appelez super(...) avant d’utiliser this, faute de quoi cet accès lève une ReferenceError. Vous pouvez omettre super() si vous renvoyez directement un objet sans utiliser this. Si vous omettez entièrement le constructeur dérivé, le constructeur par défaut transmet les arguments.
Exemples
{
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);
}
}Résultat
true true true true Ada Lin true false TypeError
Exécutez le bloc entier dans une console qui prend en charge la syntaxe `class`. Les deux premières lignes comparent les prototypes des constructeurs et des instances ; la dernière affiche le nom de l’erreur indépendamment de son message.
Leçons associées
- JavaScript · Leçon 32 · Avancé · Version : 4