CKTIS / JavaScript
Function.prototype y la sintaxis del constructor de clase
Distingue la cadena de prototipos de una función de la propiedad `.prototype` usada para las instancias y descubre qué papel tienen `new`, `constructor` y `super()` en la herencia.
Versión: ECMAScript 2024 and the current web platform; runtime support varies
Sintaxis
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 es el objeto función incorporado del que las funciones heredan métodos como call, apply y bind. Es el prototipo directo de una función ordinaria declarada con function y de una clase sin extends. Llamar a Function.prototype() devuelve undefined, pero new Function.prototype() lanza un TypeError.
C.prototype es distinto: es una propiedad propia de una función constructora ordinaria o de una clase C. Si su valor es un objeto, new C(...) normalmente lo usa como prototipo de la instancia. Comprueba ese vínculo con Object.getPrototypeOf(instance). Un constructor también puede devolver explícitamente otro objeto. Añadir .prototype a una función flecha no permite usarla con new.
Dentro de una class, constructor(...) { ... } inicializa la instancia, normalmente mediante asignaciones a this. Los métodos públicos de instancia como read() se definen en C.prototype, y los métodos static, en C. A diferencia de lo que ocurre con una función ordinaria, llamar directamente a una clase como C(...) lanza un TypeError. Sustituir .prototype en una función ordinaria no cambia el prototipo de las instancias existentes. En una clase la propiedad no admite escritura, pero el objeto prototipo sí se puede modificar.
En class Derived extends Base, Derived hereda de Base, mientras que Derived.prototype hereda de Base.prototype. En un constructor derivado explícito, llama a super(...) antes de usar this; usarlo antes lanza un ReferenceError. Puedes omitir super() si devuelves un objeto directamente sin usar this. Si omites por completo el constructor derivado, el constructor predeterminado reenvía los argumentos.
Ejemplos
{
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);
}
}Resultado
true true true true Ada Lin true false TypeError
Ejecuta el bloque completo en una consola compatible con la sintaxis `class`. Las dos primeras líneas comparan los prototipos de los constructores y de las instancias; la última muestra el nombre del error sin depender de su mensaje.
Lecciones relacionadas
- JavaScript · Lección 32 · Avanzado · Versión: 4