JavaScript prototype (objeto prototipo)

En JavaScript, el prototipo (prototype) es un concepto muy importante, ya que proporciona a los objetos un mecanismo de herencia y compartición de propiedades. Cada objeto de JavaScript tiene un objeto prototipo asociado; a través de él se pueden compartir propiedades y métodos, reduciendo así el uso de memoria.

Todos los objetos de JavaScript heredan propiedades y métodos de un prototype (objeto prototipo).

  • PrototipoEs un objeto que sirve como plantilla o modelo para otros objetos.
  • Cuando un objeto intenta acceder a una propiedad o método y no lo encuentra en el propio objeto, JavaScript busca hacia arriba a lo largo de la cadena de prototipos hasta encontrar la propiedad o método correspondiente, o hasta alcanzar la cima de la cadena de prototiposnullhasta ese límite.

La propiedad __proto__ del objeto

Cada objeto de JavaScript (excepto null) tiene automáticamente una propiedad oculta __proto__, que apunta al objeto prototipo de dicho objeto. Este __proto__ es la clave para implementar la herencia:

let obj = {};
console.log(obj.__proto__); // 输出: [object Object], 即 obj 的原型是 Object.prototype

Constructor y prototipo

En los capítulos anteriores aprendimos a usar el constructor de un objeto:

Ejemplo

function Person(first, last, age, eyecolor) { this.firstName = first; this.lastName = last; this.age = age; this.eyeColor = eyecolor; } var myFather = new Person("John", "Doe", 50, "blue"); var myMother = new Person("Sally", "Rally", 48, "green");

Pruébalo »

También sabemos que no se pueden agregar nuevas propiedades a un objeto que ya tiene un constructor definido:

Ejemplo

Person.nationality = "English";

Pruébalo »

Para agregar una nueva propiedad, se debe añadir en la función constructora:

Ejemplo

function Person(first, last, age, eyecolor) { this.firstName = first; this.lastName = last; this.age = age; this.eyeColor = eyecolor; this.nationality = "English"; }

Pruébalo »

Cuando usas un constructor para crear un objeto, laprototypepropiedad prototype del constructor se convierte en el prototipo de todos los objetos de instancia creados por ese constructor.

Ejemplo

function Person(name) {
    this.name = name;
}

Person.prototype.sayHello = function() {
    console.log("Hello, my name is " + this.name);
};

let alice = new Person("Alice");
alice.sayHello(); // Salida: Hello, my name is Alice

En este ejemplo, Person.prototype es el prototipo del objeto alice, por lo tanto alice puede acceder al método sayHello.


Cadena de prototipos

En JavaScript, los objetos implementan la herencia mediante la cadena de prototipos (prototype chain). Cuando un objeto intenta acceder a una propiedad o método, JavaScript primero comprueba si el propio objeto tiene esa propiedad o método. Si no lo tiene, busca a lo largo de la cadena de prototipos.

let obj = {};
console.log(obj.toString()); // 输出: [object Object]
// 这个 `toString` 方法实际上是从 `Object.prototype` 继承过来的

En el ejemplo anterior, el objeto obj no define el método toString, por lo tanto JavaScript busca a lo largo de la cadena de prototipos y finalmente lo encuentra en Object.prototype.


Modificar el prototipo

Puedes modificar dinámicamente el prototipo de un objeto, lo que afecta a todos los objetos creados a partir de ese prototipo:

Ejemplo

function Person(name) {
    this.name = name;
}

Person.prototype.sayHello = function() {
    console.log("Hello, my name is " + this.name);
};

let bob = new Person("Bob");
bob.sayHello(); // Salida: Hello, my name is Bob

// Modificar el prototipo
Person.prototype.sayGoodbye = function() {
    console.log("Goodbye from " + this.name);
};

bob.sayGoodbye(); // Salida: Goodbye from Bob

En este ejemplo, agregamos un nuevo método sayGoodbye en Person.prototype, y el objeto bob puede acceder de inmediato a este nuevo método.


Método Object.create

El método Object.create te permite crear un nuevo objeto y establecer su prototipo como el objeto especificado.

Ejemplo

let personPrototype = {
    sayHello: function() {
        console.log("Hello, my name is " + this.name);
    }
};

let alice = Object.create(personPrototype);
alice.name = "Alice";
alice.sayHello(); // Salida: Hello, my name is Alice

En este ejemplo, el prototipo de alice es personPrototype, por lo tanto el objeto alice puede acceder al método sayHello.


Herencia de prototype

Todos los objetos de JavaScript heredan propiedades y métodos de un prototype (objeto prototipo):

  • DateLos objetos deDate.prototypeheredan.
  • ArrayLos objetos deArray.prototypeheredan.
  • PersonLos objetos dePerson.prototypeheredan.

Todos los objetos en JavaScript son instancias de Object, que se encuentra en la cima de la cadena de prototipos.

Los objetos de JavaScript tienen una cadena que apunta a un objeto prototipo. Cuando se intenta acceder a una propiedad de un objeto, no solo se busca en ese objeto, sino también en el prototipo del objeto, y en el prototipo del prototipo del objeto, y así sucesivamente hacia arriba, hasta que se encuentra una propiedad con el nombre coincidente o se llega al final de la cadena de prototipos.

DateLos objetos,Arraylos objetos yPersonlos objetos deObject.prototypeheredan.

Agregar propiedades y métodos

A veces queremos agregar nuevas propiedades o métodos a todos los objetos existentes.

Además, a veces queremos agregar propiedades o métodos al constructor de un objeto.

Usando la propiedad prototype se pueden agregar nuevas propiedades al constructor de un objeto:

Ejemplo

function Person(first, last, age, eyecolor) { this.firstName = first; this.lastName = last; this.age = age; this.eyeColor = eyecolor; } Person.prototype.nationality = "English";

Pruébalo »

Por supuesto, también podemos usar la propiedad prototype para agregar nuevos métodos al constructor de un objeto:

Ejemplo

function Person(first, last, age, eyecolor) { this.firstName = first; this.lastName = last; this.age = age; this.eyeColor = eyecolor; } Person.prototype.name = function() { return this.firstName + " " + this.lastName; };

Pruébalo »
Otras extensiones