How to use JS prototype and prototype chain

This time I will show you how to use JS prototype and prototype chain, and what are the precautions for using JS prototype and prototype chain. The following is a practical case, let's take a look.

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.

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 be found, 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

Every addition in the previous example One attribute and method requires one type of Person.prototype. 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 object

All native reference types (Object, Array, String, etc.) have methods defined on the prototype of their 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 methods of another reference type. 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 description:

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.

I believe you have mastered the method after reading the case in this article. For more exciting information, please pay attention to other related articles on the php Chinese website!

Recommended reading:

preload() function and image upload using

react native video to make full screen effect

The above is the detailed content of How to use JS prototype and prototype chain. For more information, please follow other related articles on the PHP Chinese website!