¿Qué es la herencia prototípica en JavaScript…

En JavaScript, los objetos heredan propiedades y métodos de sus prototipos. El prototipo de cada objeto es otro objeto, cuyas propiedades y métodos están disponibles a través de la cadena de prototipos.

Al acceder a una propiedad de un objeto, JavaScript primero la busca directamente en el objeto. Si no se encuentra, la búsqueda continúa en el prototipo de ese objeto, luego en el prototipo del prototipo, y así sucesivamente, hasta que la propiedad se encuentre o se alcance el final de la cadena (null).

La herencia prototípica difiere de la herencia clásica (como en Java o C++), donde los objetos se crean a partir de clases que describen su estructura y comportamiento. En JavaScript, las clases, que aparecieron en ES6, son una sintaxis azúcar sobre la herencia prototípica.

Aspectos principales:

__proto__: Propiedad interna del objeto que hace referencia a su prototipo.
prototype: Propiedad del constructor (función utilizada como constructor), que hace referencia al objeto que servirá como prototipo para las instancias creadas.
Object.getPrototypeOf(obj): Forma estándar de obtener el prototipo de un objeto.
Object.setPrototypeOf(obj, proto): Forma estándar de establecer el prototipo de un objeto.

Ejemplo:

// Función constructora
function Animal(name) {
  this.name = name;
}

// Añadimos método al prototipo Animal
Animal.prototype.sayHello = function() {
  console.log(`Hola, mi nombre es ${this.name}`);
};

// Crear instancia
const dog = new Animal("Buddy");

// Llamar método del prototipo
dog.sayHello(); // Salida: Hola, mi nombre es Buddy

// El prototipo de dog es Animal.prototype
console.log(Object.getPrototypeOf(dog) === Animal.prototype); // true

// El prototipo de Animal.prototype es Object.prototype
console.log(Object.getPrototypeOf(Animal.prototype) === Object.prototype); // true

// El final de la cadena de prototipos es null
console.log(Object.getPrototypeOf(Object.prototype) === null); // true

Comparación con herencia clásica (usando clases ES6):

class Animal {
  constructor(name) {
    this.name = name;
  }

  sayHello() {
    console.log(`Hola, mi nombre es ${this.name}`);
  }
}

class Dog extends Animal {
  constructor(name, breed) {
    super(name); // Llamada al constructor de la clase padre
    this.breed = breed;
  }

  bark() {
    console.log("¡Guau!");
  }
}

const buddy = new Dog("Buddy", "Golden Retriever");
buddy.sayHello(); // Salida: Hola, mi nombre es Buddy (heredado de Animal)
buddy.bark(); // Salida: ¡Guau! (método de Dog)

// Las clases en ES6 son azúcar sintáctico sobre los prototipos
console.log(Object.getPrototypeOf(Dog) === Animal); // true (herencia de clases)
console.log(Object.getPrototypeOf(Dog.prototype) === Animal.prototype); // true (herencia de métodos a través de prototipos)
console.log(Object.getPrototypeOf(buddy) === Dog.prototype); // true (la instancia hereda del prototipo de la clase)

La herencia prototípica es un concepto clave en JavaScript, cuya comprensión es esencial para trabajar eficazmente con el lenguaje.

¿Qué es la herencia prototípica en JavaScript?