Cómo funcionan los prototipos en JavaScript

Los prototipos en JavaScript permiten que múltiples objetos compartan métodos sin duplicar código. Con funciones constructoras, el operador new, la referencia this y la propiedad prototype, se logra un diseño más eficiente en memoria y fácil de mantener. Aquí verás, con ejemplos prácticos en consola, cómo evitar copias innecesarias de métodos como saludar y cómo inspeccionar relaciones con Object.getPrototypeOf e instanceof.

¿Qué son los prototipos en JavaScript y por qué optimizan memoria?

Imagina una fábrica de teléfonos: todos pueden llamar, enviar mensajes y tomar fotos. Sería ineficiente reprogramar cada función en cada equipo. Así actúan los prototipos: un “sistema operativo” común que comparte métodos entre instancias. En JavaScript, los objetos creados desde una misma función constructora pueden usar los mismos métodos definidos en su prototype.

• Métodos compartidos: evitan duplicar lógica en cada objeto.
• Menor uso de memoria: una sola función para todas las instancias.
• Mantenimiento más simple: cambios en un punto común.

¿Qué problema genera duplicar métodos?

Si defines el método dentro del constructor, cada objeto crea su propia copia. Comparar con triple igualdad (===) entre dos métodos de instancias distintas devuelve false, evidenciando la duplicación.

function persona(nombre, edad) {
  this.nombre = nombre;
  this.edad = edad;
  this.saludar = function () {
    console.log(`Hola, soy ${this.nombre} y tengo ${this.edad} años`);
  };
}

const maria = new persona('María', 30);
const carlos = new persona('Carlos', 25);
console.log(maria.saludar === carlos.saludar); // false (cada uno tiene su copia)

¿Cómo crear constructores y métodos sin duplicados con prototype?

La práctica recomendada es definir propiedades en la función constructora y métodos en el prototype. Así, todas las instancias comparten la misma referencia al método.

function persona(nombre, edad) {
  this.nombre = nombre;
  this.edad = edad;
}

persona.prototype.saludar = function () {
  console.log(`Hola, soy ${this.nombre} y tengo ${this.edad} años`);
};

const ana = new persona('Ana', 28);
const luis = new persona('Luis', 32);
console.log(ana.saludar === luis.saludar); // true (mismo método compartido)

• Define propiedades con this en el constructor.
• Agrega métodos a persona.prototype una sola vez.
• Reutiliza la misma función entre todas las instancias.

¿Cómo evitar errores con this y nombres de propiedades?

Un desajuste como usar this.name en el método y this.nombre en el constructor provoca undefined. Asegura consistencia de nombres.

• Mantén el mismo identificador en propiedades y métodos.
• Verifica en consola con console.log el valor de this.
• Evita cambios entre español e inglés en nombres de propiedades.

¿Cómo inspeccionar el prototype y validar relaciones con Object.getPrototypeOf e instanceof?

Además de compartir métodos, necesitas verificar la cadena de prototipos y la relación entre instancias y sus constructores. Con Object.getPrototypeOf obtienes el prototipo real de un objeto. Con instanceof validas si un objeto fue creado por un constructor específico.

function animal(nombre) {
  this.nombre = nombre;
}

animal.prototype.comer = function () {
  console.log(`${this.nombre} está comiendo`);
};

const gato = new animal('Gato');

const proto = Object.getPrototypeOf(gato);
console.log(proto === animal.prototype); // true (apunta al mismo prototype)
console.log(gato instanceof animal);     // true (gato fue creado con animal)

• Usa Object.getPrototypeOf(obj) para leer el prototipo actual.
• Compara con Constructor.prototype para confirmar igualdad.
• Valida con instanceof la relación instancia-constructor.
• Centraliza métodos como comer en el prototype para reutilizarlos.

¿Te quedó alguna duda o quieres compartir tu ejemplo usando prototype, Object.getPrototypeOf o instanceof? Escribe tu comentario y conversemos sobre buenas prácticas con prototipos en JavaScript.