JS core series: A brief discussion of prototype objects and prototype chains

In Javascript, everything is an object, but objects are also different and can be roughly divided into two categories, namely: ordinary objects (Object) and function objects (Function).

Generally speaking, the objects generated through new Function are function objects, and other objects are ordinary objects.

Example:

function f1(){
    //todo
}
var f2 = function(){
    //todo
};
var f3 = new Function('x','console.log(x)');

var o1 = {};
var o2 = new Object();
var o3 = new f1();

console.log(
    typeof f1,//function
    typeof f2,//function
    typeof f3,//function
    typeof o1,//object
    typeof o2,//object
    typeof o3 //object
);
>> function function function object object object

f1 is a function declaration, the most common function definition method, f2 is actually an anonymous function, and this anonymous function is assigned to f2, which is a function expression , f3 is not common, but it is also a function object.

Function is an object that comes with JS. When f1 and f2 are created, JS will automatically build these objects through new Function(). Therefore, these three objects are all through new Function() Created.

There are two ways to create objects in Javascript: object literals and using new expressions. The creation of o1 and o2 corresponds to these two ways. Let’s focus on o3. If you use Java and C# ideas To understand, o3 is an instance object of f1, and o3 and f1 are of the same type. At least I used to think so, but it’s not the case...

So how do you understand it? It’s very simple, see if o3 passes new Function What is generated is obviously not, since it is not a function object, it is an ordinary object.

After a simple understanding of function objects and ordinary objects, let’s take a look at the prototype and prototype chain in Javascript:

In JS, whenever a function object f1 is created, the There are some attributes built into the object, including prototype and __proto__. prototype is the prototype object, which records some attributes and methods of f1.

It should be noted that prototype is invisible to f1, that is to say, f1 will not search for the properties and methods in prototype.

function f(){}
f.prototype.foo = "abc";
console.log(f.foo); //undefined

So, what is the use of prototype? In fact, the main function of prototype is inheritance. In layman's terms, the properties and methods defined in the prototype are reserved for its own "descendants". Therefore, subclasses can fully access the properties and methods in the prototype.

To know how f1 leaves the prototype to "descendants", we need to understand the prototype chain in JS. At this time, __proto__ in JS enters the scene. This guy looks very strange and hidden. is also very deep, so you often don’t see it, but it exists in both ordinary objects and function objects. Its function is to save the prototype object of the parent class. When JS creates an object through the new expression, it usually The prototype of the parent class will be assigned to the __proto__ attribute of the new object. In this way, a generational inheritance will be formed...

function f(){}
f.prototype.foo = "abc";var obj = new f();
console.log(obj.foo); //abc

Now we know that __proto__ is saved in obj is the prototype of f, so what is stored in __proto__ in the prototype of f? Look at the picture below:

As shown in the picture, f.prototype What is saved in __proto__ is Object.prototype, and there is also __proto__ in the Object.prototype object. From the output result, Object.prototype.__proto__ is null, indicating the end of the obj object prototype chain. As shown in the figure below:

After the obj object has such a prototype chain, when obj.foo is executed, obj will first search whether it has this attribute, but will not search. For its own prototype, when foo cannot be found, obj will search along the prototype chain...

In the above example, we defined the foo attribute on f's prototype, and then obj will This property will be found on the prototype chain and executed.

Finally, use a few sentences to summarize the key points involved in this article:

1. The formation of the prototype chain really depends on_ _proto__ instead of prototype. When the JS engine executes an object's method, it first checks whether the method exists in the object itself. If it does not exist, it will search on the prototype chain, but not its own prototype.

2. An object's __proto__ records its own prototype chain and determines its own data type. Changing __proto__ is equivalent to changing the object's data type.

3. The prototype of a function does not belong to its own prototype chain. It is the core of subclass creation, determines the data type of the subclass, and is the bridge connecting the prototype chain of the subclass.

4. The purpose of defining methods and properties on the prototype object is to be inherited and used by subclasses.