In-depth introduction to JavaScript prototype property_javascript skills

Each function is created with a prototype attribute by default, which contains a constructor attribute and a hidden attribute __proto__ pointing to the Object object. The value of the constructor attribute is the object of the function. Calling a function with new in front of it will create a new object that is hidden and connected to the prototype member of the function (linked by the __proto__ attribute), and the this of the function will be bound to that new object.
The function always returns a value; if no return value is specified, it returns undefined; if it is called as a constructor and the return value is not an object, it returns this (the new object); if the return value is an object, it Being a constructor makes no sense!
[javascript]

Copy code The code is as follows:

function A(){
this.p = 'haha';
return {p:'heihei'};
}
var a = new A();
function A(){
this. p = 'haha';
return {p:'heihei'};
}
var a = new A();
alert(a.p);//Display 'heihei', the same as var a = A(); has the same effect

Function A directly calls a function B internally, and B’s this is bound to the global object instead of its external function A. This is an error in JS design. We have to use other ways to solve this problem, such as using a variable (usually that) in A to save a reference to A's this scope.
JS function has a length attribute, which indicates the number of formal parameters specified when the function is defined.
The arguments attribute of a function contains all the parameters passed in when calling the function, regardless of whether these formal parameters are defined in the function declaration; arguments is not an array, but an "array-like" object (run arguments instanceof in the function Array; returns false). It can be converted into a JS array through Array.prototype.slice.apply(arguments).
Add a method to the prototype of the JavaScript function, and all (constructor) functions can be used! For example, you can add a method method to the prototype of the JS function constructor Function, and all functions, including Object, Number and other constructors, will inherit this method. This is very powerful:
[javascript]

Copy code The code is as follows:

Function.prototype.method = function(name, func){
this.prototype[name] = func;
return this;
};
Function.prototype.method = function(name, func){
this.prototype[name] = func;
return this;
};

In this way, by calling the Object.method method, you can add new methods to all JS objects (including Function objects) and call the Number.method method , you can add new methods for all numerical types, the following is an example of this. Note that objects of types such as Object and Number do not inherit the method method at this time. If you want to achieve this goal, you can run a statement similar to the following:
[javascript]

Copy code The code is as follows:

Object.method('method',Object.method);
Object.method('method',Object.method);

We can modify The prototype of the numerical type is used to add new methods to the numerical type. Here we borrow the method method mentioned in the previous article to add a negative method to the prototype of Number:
[javascript]

Copy code The code is as follows:

Number.method(negative,function(){
return 0–this;
})
Number.method(negative,function(){
return 0–this;
})

There is a little twist when calling the method. In the syntax of JavaScript, the syntax of directly following a number with a period, and then followed by a method call is wrong; in other words, it is wrong to write 3.negative() like this. To call a numeric type method, you need to add n spaces (n>=1) after the number, or use parentheses to enclose the number and force it into an expression, and then call the method, or simply define a value Variables can also call methods directly. In other words, the following writing methods are correct:
[javascript]
(3).negative();
3 .negative();
var n = 3; n.negative( );
3['negative']();
(3).negative();
3 .negative();
var n = 3; n.negative();
3['negative']();
When using the function expression method to define a function, the function name after function can be used to call itself recursively, and this name will not be overwritten! Let’s look at the following example,
[javascript]

Copy code The code is as follows:

function a(n){
if(n>1)
return a(n-1) 1;
else
return 1;
};
function a(n ){
if(n>1)
return a(n-1) 1;
else
return 1;
};

The above code definition We have a function a, and it calls itself recursively internally; now we use a new reference aa to point to the function a, and then change the original a, for example, into an integer 1, and then call the function aa, as shown in the following code Display:
[javascript]

Copy code The code is as follows:

var aa = a ;
a = 1;
aa(3);
var aa = a;
a = 1;
aa(3);

then control The station reported an error: TypeError: Property 'a' of object [object Window] is not a function; obviously, the original recursive function has been destroyed. Regarding this issue, we can replace a with arguments.callee.caller inside function a, or use a function expression to define the function:
[javascript]

Copy code The code is as follows:

var b = function a(n){
if(n>1)
return a( n-1) 1;
else
return 1;
};
var bb = b;
a = 3;
bb(3);
var b = function a(n){
if(n>1)
return a(n-1) 1;
else
return 1;
};
var bb = b;
a = 3;
bb(3);

At this point, the bb function can correctly return the result we want.
In order to improve the encapsulation of JavaScript functions, we can define functional constructors. Here is an example:

Copy code The code is as follows:

[javascript]
var funcCons = function(spec){
var that = {};
that.getName = function(){
return spec.name;
};
that.says = function(){
return spec.saying || '';
};
return that;
};
var myFunc = funcCons({name:'NearEast'});
var funcCons = function(spec){
var that = {};
that.getName = function(){
return spec.name;
};
that.says = function(){
return spec.saying || '';
};
return that;
};
var myFunc = funcCons({name:'NearEast'});

In this way, we can define some private variables (such as dictionary tables) and functions in the constructor without having to put them all Exposed.