¿Cómo funciona la herencia prototípica?

Question

Accepted Answer

Todo objeto de JavaScript tiene un enlace oculto a otro objeto llamado su **prototipo**. Cuando accedes a una propiedad, JS la busca en el objeto mismo, luego recorre hacia arriba esta **cadena de prototipos** hasta encontrar la propiedad o llegar a `null`. Esto es *delegación*, no copia.

```js
const animal = {
  speak() { return `${this.name} makes a sound`; },
};

const dog = Object.create(animal); // dog's prototype IS animal
dog.name = "Rex";
dog.speak();                       // "Rex makes a sound" — found on the prototype

Object.getPrototypeOf(dog) === animal; // true
dog.hasOwnProperty("speak");           // false — it's inherited, not own
dog.hasOwnProperty("name");            // true
```

## Cómo lo usan las clases

`class` es azúcar sintáctico sobre los prototipos. Los métodos viven **una sola vez** en el prototipo, compartidos por todas las instancias (no se copian por objeto):

```js
class Dog {
  constructor(name) { this.name = name; }
  speak() { return `${this.name} barks`; } // on Dog.prototype
}
const d = new Dog("Rex");
Object.getPrototypeOf(d) === Dog.prototype; // true
```

Así que `d.speak` no se almacena en `d` — se encuentra recorriendo hacia arriba hasta `Dog.prototype`. Por eso todos los perros comparten una sola función `speak` (eficiente en memoria).

## Por qué es importante

Entender la cadena explica: por qué las instancias comparten métodos, por qué cambiar un prototipo afecta a todos los objetos enlazados, cómo funciona `instanceof` (verifica la cadena) y el costo de cadenas de búsqueda largas.

Es la base que sustenta `class`, los integrados (`Array.prototype.map`) y la herencia.