Detailed explanation of javascript prototype and prototype chain

Every function we create has a prototype (prototype) attribute. This attribute is a pointer pointing to a prototype object, and the properties and methods in this prototype object can be shared by all instances. This article mainly gives you a detailed analysis of the relevant knowledge points and usage sharing of JavaScript prototypes and prototype chains. Friends who are interested can refer to it. I hope it can help everyone.

function Person(){
}
Person.prototype.name = "Nicholas";
Person.prototype.age = 29;
Person.prototype.sayName = function(){
alert(this.name);
};
var person1 = new Person();
person1.sayName(); //"Nicholas"
var person2 = new Person();
person2.sayName(); //"Nicholas"
alert(person1.sayName == person2.sayName); //true

1. Understanding prototype objects

Whenever a new function is created, a prototype attribute will be created for the function according to a specific set of rules. , this attribute points to the prototype object of the function.

By default, all prototype objects automatically obtain a constructor property, which contains a pointer to the function where the prototype property is located.

When the constructor is called to create a new instance, the instance will contain a pointer (internal property) pointing to the prototype object of the constructor. ECMA-262 version 5 refers to this pointer as [[Prototype]].

Although there is no standard way to access [[Prototype]] in scripts, Firefox, Safari, and Chrome support an attribute __proto__ on each object; in other implementations, this attribute is not available to scripts. is completely invisible.

However, the really important point to make clear is that this connection exists between the instance and the prototype object of the constructor, not between the instance and the constructor.

Take the previous code that uses the Person constructor and Person.prototype to create an instance as an example. Figure 6-1 shows the relationship between each object.

Here, Person.prototype points to the prototype object, and Person.prototype.constructor points back to Person .

Both person1 and person2 contain an internal property that simply points to Person.prototype; in other words, they have no direct relationship with the constructor.

You can call person1.sayName(). This is accomplished through the process of finding object properties. (It will search on the instance first, and if it cannot find it, it will continue to search for the prototype.)

用isPrototypeOf()方法判断实例与原型对象之间的关系
alert(Person.prototype.isPrototypeOf(person1)); //true
alert(Person.prototype.isPrototypeOf(person2)); //true

用Object.getPrototypeOf() 方法返回实例的原型对象
alert(Object.getPrototypeOf(person1) == Person.prototype); //true

使用 hasOwnProperty() 方法可以检测一个属性是存在于实例中，还是存在于原型中。
alert(person1.hasOwnProperty("name")); //false　　来着原型
person1.name = "Greg";
alert(person1.name); //"Greg"——来自实例
alert(person1.hasOwnProperty("name")); //true

2. Simpler prototype syntax

In the previous example, Person.prototype needs to be typed every time a property and method is added. In order to reduce unnecessary typing and to better visually encapsulate the functionality of the prototype, it is more common to override the entire prototype object with an object literal that contains all properties and methods.

function Person(){
}
Person.prototype = {
　　name : "Nicholas",
　　age : 29,
　　job: "Software Engineer",
　　sayName : function () {
　　　　alert(this.name);
　　}
};

In the above code, we set Person.prototype equal to a new object created as an object literal. The end result is the same, with one exception: the constructor property no longer points to Person .

As introduced before, every time a function is created, its prototype object will be created at the same time, and this object will also automatically obtain the constructor property.

var friend = new Person();
alert(friend instanceof Object); //true
alert(friend instanceof Person); //true
alert(friend.constructor == Person); //false
alert(friend.constructor == Object); //true

Here, using the instanceof operator to test Object and Person still returns true, but the constructor property is equal to Object and not equal to Person.

If the value of constructor is really important, you can deliberately set it back to the appropriate value as shown below.

function Person(){
}
Person.prototype = {
  constructor : Person,
  name : "Nicholas",
  age : 29,
  job: "Software Engineer",
  sayName : function () {
    alert(this.name);
  }
};

3. Prototype of native objects

All native reference types (Object, Array, String, etc.) are in Methods are defined on the prototype of its constructor.

For example, the sort() method can be found in Array.prototype, and the substring() method can be found in String.prototype. Although it is possible to do so, it is not recommended to modify the prototype of a native object.

4. Problems with Prototype Objects

The biggest problem with the prototype pattern is caused by its shared nature. Modifying one of them will affect the other.

function Person(){
}
Person.prototype = {
constructor: Person,
name : "Nicholas",
age : 29,
job : "Software Engineer",
friends : ["Shelby", "Court"],
sayName : function () {
alert(this.name);
}
};
var person1 = new Person();
var person2 = new Person();
person1.friends.push("Van");
alert(person1.friends); //"Shelby,Court,Van"
alert(person2.friends); //"Shelby,Court,Van"
alert(person1.friends === person2.friends); //true

5. Prototype chain

The basic idea is to use prototypes to let one reference type inherit the properties and properties of another reference type. method. Then, layer by layer, a chain of instances and prototypes is formed. This is the basic concept of the so-called prototype chain.

function SuperType(){
　　this.property = true;
}
SuperType.prototype.getSuperValue = function(){
　　return this.property;
};
function SubType(){
　　this.subproperty = false;
}
//继承了 SuperType
SubType.prototype = new SuperType();
SubType.prototype.getSubValue = function (){
　　return this.subproperty;
};
var instance = new SubType();
alert(instance.getSuperValue()); //true

A picture illustrates:

property is located in SubType.prototype. This is because property is an instance property and getSuperValue() is a prototype method. Since SubType.prototype is now an instance of SuperType, of course the property is located in that instance.

Related:

JS prototype and prototype chain detailed explanation

# #

The above is the detailed content of Detailed explanation of javascript prototype and prototype chain. For more information, please follow other related articles on the PHP Chinese website!