Prototype and prototype chain in JS

JS The archetype of and Prototype chain It is a hot topic for front-end interview questions , Basically, the probability of meeting is very high ！

        First , What is a prototype ？

every last javascript object ( except null Outside ) At the time of creation , Will be associated with another object , This object is what we call prototype , Every object comes from the prototype “ Inherit ” attribute .

for instance ：

function Person(age) {
    this.age = age       
}
Person.prototype.name = 'kavin'
var person1 = new Person()
console.log(person1.name)  //kavin

  That is to say, through Constructors When creating an instance , If you look for an attribute value in an instance , If he has one, he will output it directly , If not , Will go to its prototype object to find .

prototype： Each function has one prototype attribute , This property points to the prototype object of the function .

__proto__: This is every object ( except null Outside ) There will be properties , be called __proto__, This property points to the prototype of the object .

constructor: Each prototype has a constructor attribute , The constructor pointing to the Association .

The knowledge test sites related to prototypes are generally around this picture , So how to verify the correctness of this diagram ？

console.log(Person===Person.prototype.constructor)  // true
console.log(person.__proto__ == Person.prototype) // true
console.log(person.__proto__.constructor == Person) // true
console.log(person.constructor == Person) // true

Then what is the prototype chain ？

Simply review the constructor 、 Relationship between prototype and instance ： Each constructor has a prototype object , The prototype object contains a pointer to the constructor , Instances contain an internal pointer to the prototype object . So if we make the prototype object equal to an instance of another type , What will happen ？ obviously , The prototype object at this point will contain a pointer to another prototype , Accordingly , Another prototype also contains a pointer to another constructor . If another prototype is another instance of another type , So the above relationship still holds . And so on , It forms a chain of instances and prototypes .

The simple expression is ： As mentioned above, if the instance does not have a property , It will go to its prototype to find , But what if it doesn't have this attribute in its prototype , Will you stop looking , not always , Because its prototype may also have its own prototype , At this time, he will go to the prototype of its prototype to find , Will it stop at this time , Not necessarily , It depends on whether his prototype has a prototype , In this way, a prototype chain is formed .

Until the last prototype cannot be found, return null