Home > Article > Web Front-end > What are prototype objects and prototype chains in js

What are prototype objects and prototype chains in js

巴扎黑Original: 2017-07-18 17:04:171338browse

In Javascript, everything is an object, but objects are also different, and they can be roughly divided into two categories, namely: Common object Object and Function object 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 way to define a function. f2 is actually an anonymous function. This anonymous function is assigned to f2, which is a function expression. Formula, 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 is not the case...

So how do you understand it? 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, thus forming a generational inheritance...

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

As shown in the figure, Object.prototype is stored in __proto__ of f.prototype. There is also __proto__ in the Object.prototype object. From the output results, Object. prototype.__proto__ is null, indicating the end of the prototype chain of the obj object. 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, summarize the key points involved in this article in a few sentences:

The formation of the prototype chain really relies on __proto__ rather than 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 will not search its own prototype.
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.
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.
The purpose of defining methods and properties on the prototype object is to be inherited and used by subclasses.

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

The above is the detailed content of What are prototype objects and prototype chains in js. For more information, please follow other related articles on the PHP Chinese website!

Statement：

The content of this article is voluntarily contributed by netizens, and the copyright belongs to the original author. This site does not assume corresponding legal responsibility. If you find any content suspected of plagiarism or infringement, please contact admin@php.cn

Previous article：A brief tutorial on desktop program development using VS2017 and jsNext article：A brief tutorial on desktop program development using VS2017 and js

See more

What are prototype objects and prototype chains in js

Related articles