Saltar al contenido
Objetos

Prototipos y la cadena de prototipos

Lección 6 de 712 min4 ejercicios

Creas un objeto vacío y ya tiene toString. Creas un array y ya tiene map, filter y push. ¿De dónde salen? De su prototipo: un objeto oculto al que cada objeto está enlazado, y donde el motor busca lo que el objeto no tiene. Es el mecanismo de herencia de JavaScript, y lo que las clases usan por debajo.

Qué mirar en el pizarrón

Cada objeto indica cuál es su prototipo. En las líneas 8 a 10, fíjate en qué eslabón de la cadena encuentra el motor cada propiedad, y qué pasa cuando no está en ninguno.

En el pizarrón

const animal = {  respirar() { return "respira"; },}; const perro = Object.create(animal);perro.ladrar = function () { return "guau"; }; console.log(perro.ladrar());console.log(perro.respirar());console.log(perro.volar);

Variables

  1. animal→ objeto #1
  2. objeto #1{ respirar } · prototipo: Object.prototype
  3. Object.prototype{ toString, hasOwnProperty, … } · prototipo: null
Consola(vacía)

Todo objeto tiene un enlace oculto a otro objeto: su prototipo. Un literal enlaza con Object.prototype, de donde salen métodos como toString. El prototipo de Object.prototype es null: ahí termina la cadena.

Con el foco aquí también puedes avanzar y retroceder con las flechas del teclado.

Ver todos los pasos en texto
  1. Paso 1: Todo objeto tiene un enlace oculto a otro objeto: su prototipo. Un literal enlaza con Object.prototype, de donde salen métodos como toString. El prototipo de Object.prototype es null: ahí termina la cadena. Variables: animal → objeto #1, objeto #1 { respirar } · prototipo: Object.prototype, Object.prototype { toString, hasOwnProperty, … } · prototipo: null.
  2. Paso 2: Object.create(animal) crea un objeto vacío cuyo prototipo es animal. Así se forma una cadena: perro → animal → Object.prototype → null. Variables: animal → objeto #1, perro → objeto #2, objeto #2 { } · prototipo: objeto #1, objeto #1 { respirar } · prototipo: Object.prototype, Object.prototype { toString, hasOwnProperty, … } · prototipo: null.
  3. Paso 3: ladrar se agrega a perro: es una propiedad propia. animal no la tiene. Variables: animal → objeto #1, perro → objeto #2, objeto #2 { ladrar } · prototipo: objeto #1, objeto #1 { respirar } · prototipo: Object.prototype, Object.prototype { toString, hasOwnProperty, … } · prototipo: null.
  4. Paso 4: Para leer perro.ladrar, el motor busca primero en el propio objeto. Está ahí: la usa. Variables: animal → objeto #1, perro → objeto #2, objeto #2 { ladrar } ✓ encontrada, objeto #1 { respirar } · prototipo: Object.prototype, Object.prototype { toString, hasOwnProperty, … } · prototipo: null.
  5. Paso 5: respirar no está en perro, así que el motor sube a su prototipo, animal, y la encuentra. perro no la copió: la hereda por la cadena. Variables: animal → objeto #1, perro → objeto #2, objeto #2 { ladrar } · no está, sube, objeto #1 { respirar } ✓ encontrada, Object.prototype { toString, hasOwnProperty, … } · prototipo: null.
  6. Paso 6: volar no está en ningún eslabón. El motor recorre la cadena entera hasta null y devuelve undefined. Esta búsqueda es la base de las clases en JavaScript, que verás en la próxima sección. Variables: animal → objeto #1, perro → objeto #2, objeto #2 { ladrar } · no está, sube, objeto #1 { respirar } · no está, sube, Object.prototype { toString, … } · no está · prototipo: null.

El prototipo

Todo objeto tiene un enlace interno, que la especificación llama [[Prototype]], a otro objeto: su prototipo. Puedes verlo con Object.getPrototypeOf:

const vacio = {};
console.log(Object.getPrototypeOf(vacio) === Object.prototype);  // true
console.log(vacio.toString());  // [object Object]: heredado

const lista = [1, 2];
console.log(Object.getPrototypeOf(lista) === Array.prototype);   // true

La cadena de prototipos

Cuando lees una propiedad, el motor:

  1. La busca en el propio objeto.
  2. Si no está, la busca en su prototipo.
  3. Después, en el prototipo del prototipo, y así hacia arriba.
  4. Si llega a null sin encontrarla, devuelve undefined.

Es la misma idea que la cadena de scopes del tema Scope, pero con objetos en lugar de variables. Un array, por ejemplo, tiene esta cadena:

lista  →  Array.prototype  →  Object.prototype  →  null
          (map, filter…)      (toString, hasOwnProperty…)

Por eso un array tiene a la vez map y toString: los dos están en su cadena.

Object.create

Object.create(proto) crea un objeto vacío con el prototipo que elijas. Es la forma más directa de ver la herencia en acción:

const vehiculo = {
  ruedas: 4,
  describir() {
    return `Tengo ${this.ruedas} ruedas`;
  },
};

const moto = Object.create(vehiculo);
moto.ruedas = 2;  // propia: tapa a la heredada

console.log(moto.describir());  // usa el método heredado con el dato propio
console.log(Object.hasOwn(moto, "ruedas"));     // true
console.log(Object.hasOwn(moto, "describir"));  // false: heredado

Escribir no sube por la cadena: moto.ruedas = 2 crea una propiedad propia en moto, aunque vehiculo ya tenga ruedas. La propia tapa a la heredada, y vehiculo no cambia.

Object.create(null) crea un objeto sin prototipo: no hereda nada, ni siquiera toString. Se usa a veces como diccionario “limpio”.

Por qué importa

  • Los métodos se comparten. Un método en el prototipo existe una sola vez, aunque haya un millón de objetos que lo usen.
  • this es quien llama. El método vive en el prototipo, pero this es el objeto desde el que se lo llamó, así que trabaja con sus datos.
  • Así funcionan las clases. class es una sintaxis más cómoda sobre este mismo mecanismo: los métodos van al prototipo y los datos, a cada instancia. Lo vas a ver en la próxima sección.

Resumen

  • Todo objeto tiene un prototipo (Object.getPrototypeOf), salvo los creados con Object.create(null).
  • Para leer una propiedad, el motor sube por la cadena de prototipos hasta encontrarla o llegar a null.
  • Escribir crea siempre una propiedad propia, que tapa a la heredada.
  • Object.create(proto) crea un objeto enlazado a proto.
  • Los métodos de los nativos (map, toString…) viven en sus prototipos y se comparten.
  • No modifiques los prototipos nativos.

¡A practicar!

Tu progreso se guarda en este navegador.

Autoevaluación: Herencia por enlace

Elige una respuesta en cada pregunta.

  1. Si lees obj.x y obj no tiene x, ¿qué hace el motor?

  2. ¿Qué hace Object.create(base)?

  3. ¿Dónde está el método map que usas en [1, 2].map(…)?

  4. ¿Cuál es la forma recomendada de leer el prototipo de un objeto?

Ordena la salida: Propia o heredada

Un objeto hijo con una propiedad que también tiene su prototipo. Ordena lo que aparecería en la consola.

const base = { saludo: "hola", tipo: "base" };const hijo = Object.create(base);hijo.tipo = "hijo"; console.log(hijo.saludo);console.log(hijo.tipo);console.log(Object.hasOwn(hijo, "saludo"));console.log(Object.getPrototypeOf(hijo) === base);

Consola, de arriba abajo

  1. hijo
  2. true
  3. hola
  4. false

Detective: Parece un array, pero no lo es

Una respuesta que parece una lista no tiene map. Encuentra la línea que falla y elige el arreglo correcto.

Consola

2
lista.js:4
const nombres = respuesta.map((n) => n.toUpperCase());
                          ^

TypeError: respuesta.map is not a function

Paso 1: toca la línea de código que causa el error.

Laboratorio: Un método compartido

Crea michi enlazado a animal, con sus propios datos, para que use el método presentarse sin copiarlo.

programa.jsse ejecuta mientras escribes

$ node programa.js

(escribe tu código: se ejecuta solo)

Lo que debe cumplir

  • Imprime Michi dice miau (pendiente)
  • El prototipo de michi es animal (pendiente)
  • presentarse no es propia de michi: la hereda (pendiente)

    domina-js · JavaScript en español, gratis y paso a paso.