JavaScript
Explica cómo las funciones constructoras y new crean instancias, conectan prototipos, inicializan this y comparten métodos entre objetos.
Una función constructora es una función diseñada para ejecutarse con new y configurar objetos que comparten un prototipo.
function User(name, role) {
this.name = name;
this.role = role;
}
const user = new User("Nicolás", "developer");En una llamada:
const user = new User("Nicolás", "developer");JavaScript realiza conceptualmente estos pasos:
[[Prototype]] con User.prototype.User usando el objeto nuevo como this.Modelo aproximado:
function emulateNew(Constructor, ...args) {
const instance = Object.create(Constructor.prototype);
const result = Constructor.apply(instance, args);
const returnedObject =
result !== null &&
(typeof result === "object" ||
typeof result === "function");
return returnedObject ? result : instance;
}Es un modelo educativo, no una implementación completa de todas las reglas internas.
function Product(name, price) {
this.name = name;
this.price = price;
this.isActive = true;
}Cada llamada con new crea propiedades propias en una instancia diferente.
const keyboard = new Product("Keyboard", 120);
const mouse = new Product("Mouse", 60);
keyboard !== mouse; // trueNo es necesario crear la misma función por instancia.
Product.prototype.calculateTax = function (rate) {
return this.price * rate;
};keyboard.calculateTax === mouse.calculateTax; // trueAmbas instancias encuentran el método en Product.prototype.
Si el constructor define el método dentro:
function Product(name, price) {
this.name = name;
this.price = price;
this.calculateTax = function (rate) {
return this.price * rate;
};
}Cada instancia recibe una función diferente.
Esto puede ser correcto si el método necesita un closure privado, pero no debe hacerse sin intención.
User.prototype;Es un objeto utilizado por new como prototipo de las instancias.
Object.getPrototypeOf(user) === User.prototype; // trueLa propiedad prototype no es el prototipo de la función User como objeto. Son relaciones distintas:
Object.getPrototypeOf(User) === Function.prototype;User.prototype: objeto que heredarán sus instancias.Object.getPrototypeOf(User): prototipo de la propia función.El objeto creado como User.prototype suele contener una propiedad constructor que apunta a User.
User.prototype.constructor === User; // trueNo es una garantía de seguridad ni el mecanismo principal de creación. Puede cambiarse.
user.constructor = AnotherFunction;Por eso no debe utilizarse como prueba confiable de tipo en datos no controlados.
user instanceof User; // trueinstanceof revisa si User.prototype aparece en la cadena de prototipos de user.
No compara el nombre del constructor ni la forma de las propiedades.
const fakeUser = {
name: "Nicolás",
role: "developer",
};
fakeUser instanceof User; // falseTiene la misma forma, pero no la misma cadena prototípica.
function User(name) {
this.name = name;
return 100;
}
new User("Nicolás");El primitivo se ignora y se retorna la instancia.
function User(name) {
this.name = name;
return {
name: "Replacement",
};
}El objeto explícito reemplaza la instancia creada por new.
Esto suele confundir y puede romper la relación con User.prototype. Evítalo salvo que exista una razón clara.
function User(name) {
this.name = name;
}
User("Nicolás");En modo estricto, this es undefined y se produce un error.
En código no estricto, podría escribir accidentalmente en el objeto global. Es una de las razones por las que las clases modernas exigen new.
function User(name) {
if (!new.target) {
return new User(name);
}
this.name = name;
}new.target indica qué constructor inició la llamada con new.
Otra estrategia es lanzar un error para mantener un contrato explícito.
if (!new.target) {
throw new TypeError("User must be called with new");
}function Base() {
console.log(new.target?.name);
}
function Child() {
Base.call(this);
}
Child.prototype = Object.create(Base.prototype);
Child.prototype.constructor = Child;
new Child();En esta llamada manual mediante Base.call, new.target dentro de Base es undefined porque Base no fue invocada con new.
Las clases y super() conservan correctamente la construcción derivada mediante mecanismos internos.
Una arrow function no puede usarse con new.
const User = () => {};
new User(); // TypeErrorLos métodos abreviados tampoco son constructibles.
const object = {
create() {},
};
new object.create(); // TypeErrorMuchas funciones normales sí implementan capacidad de construcción, aunque no todas estén diseñadas semánticamente como constructores.
class User {
constructor(name) {
this.name = name;
}
}new User("Nicolás"); // Correcto.
User("Nicolás"); // TypeError.Las clases ofrecen una sintaxis más estricta sobre el sistema de prototipos.
const user = new User("Nicolás");new.this.User.prototype.instanceof.const user = createUser("Nicolás");Ningún enfoque es universalmente superior.
function Product(name, price) {
if (!name?.trim()) {
throw new TypeError("Name is required");
}
if (!Number.isFinite(price) || price < 0) {
throw new TypeError(
"Price must be a non-negative number",
);
}
this.name = name.trim();
this.price = price;
}Una construcción fallida no retorna una instancia utilizable.
Sin embargo, un constructor con demasiada lógica, I/O o dependencias ocultas puede ser difícil de probar. La creación compleja puede delegarse a factories o servicios.
function User(name) {
this.name = name;
}
const first = new User("First");
User.prototype.greet = function () {
return `Hello, ${this.name}`;
};
first.greet(); // Funciona.La instancia apunta al mismo objeto User.prototype, que fue modificado.
Pero reemplazar el objeto completo afecta solo a instancias futuras.
User.prototype = {
greet() {
return `Hi, ${this.name}`;
},
};
const second = new User("Second");
Object.getPrototypeOf(first) ===
Object.getPrototypeOf(second); // falseModificar prototipos después de crear objetos puede volver el sistema difícil de razonar. Define su comportamiento de forma estable.
function Order(id, items = []) {
if (!new.target) {
throw new TypeError("Order requires new");
}
this.id = id;
this.items = [...items];
this.status = "pending";
}
Order.prototype.complete = function () {
this.status = "completed";
};
Order.prototype.calculateTotal = function () {
return this.items.reduce(
(total, item) =>
total + item.price * item.quantity,
0,
);
};Las propiedades pertenecen a cada pedido; los métodos se comparten.
new solo llama la función normalmente.Constructor.prototype con el prototipo de la función.new y modificar el objeto global en código antiguo.constructor como verificación confiable de tipo.instanceof compara propiedades.prototype después de crear instancias.new crea un objeto, conecta su prototipo y llama al constructor con ese this.Constructor.prototype.instanceof revisa la cadena de prototipos.new.target detecta una construcción.¿Qué valor se devuelve?
function User(name) {
this.name = name;
return {
name: "Replacement",
};
}
const user = new User("Nicolás");
console.log(user.name);
console.log(user instanceof User);Imprime "Replacement" y false. El objeto retornado explícitamente reemplaza la instancia conectada a User.prototype.
Prototipos explica el mecanismo de delegación que permite a las instancias compartir comportamiento.