JS implicit parameters (Arguments,callee,caller) using the method _javascript skills

Before you mention the above concepts, first of all, let's talk about the implied parameters of functions in javascript:

Arguments

Arguments the object represents the function being executed and the arguments of the function that called it. [function.] Arguments[n] Parameter
Function: Option. The name of the Function object that is currently executing.
N: Options. The 0-based parameter value index to pass to the Function object. Description arguments is a hidden object that is created in addition to the parameters specified when a function call is made. Arguments is an array-like but not an array object, saying that it is similar to an array because it has the same access property and manner as an array, and can be accessed by arguments[n] to the value of the corresponding individual parameter and to have the length of the array. And the arguments object stores the arguments that are actually passed to the function, not the list of parameters defined by the function declaration, and the arguments object cannot be explicitly created. The arguments object is available only when the function starts.

The examples below explain these properties in detail

Copy Code code as follows:

Use of Arguments objects
function Argtest (A, b) {
var i, S = "The Argtest function expected";
var Numargs = arguments.length; Gets the numeric value of the parameter being passed.
var Expargs = argtest.length; Gets the numeric value of the expected parameter.
if (Expargs < 2)
S + + Expargs + "argument."
Else
S + + Expargs + "arguments."
if (Numargs < 2)
S + + Numargs + "was passed."
Else
S + + Numargs + "were passed."
s + + ""
For (i =0 i < Numargs; i++) {//Get parameter content.
S + + "ARG" + i + "=" + arguments + "";
}
return (s); Returns a list of parameters.
}

This adds a code stating that arguments is not an array (array Class):

Copy Code code as follows:

Array.prototype.selfvalue = 1;
Alert (new Array (). Selfvalue);
function testaguments () {
alert (Arguments.selfvalue);
}

Run the code you will find that the first alert shows 1, which means that the array object has the Selfvalue property, the value is 1, and when you call the function testaguments, you will notice that the "undefined" is displayed, stating that the attribute is not arguments. That is, arguments is not an array object.
Here is a simple way to add the recommended: alert (arguments instanceof Array);
Alert (arguments instanceof Object);

Caller

Returns a reference to a function that calls the current function.
Functionname.caller
The FunctionName object is the name of the function being executed.

Description
For functions, the caller property is only defined when the function executes. If the function is called by the top level, then caller contains null. If you use the Caller property in the string context, the result is the same as functionname.tostring, that is, the inverse compiled text of the function is displayed.
Note: function.tostring () enables the ability to decompile functions. It's more powerful with recursive functions.
The following example illustrates the use of the caller property:

Copy Code code as follows:

Caller Demo {
function Callerdemo () {
if (Callerdemo.caller) {
var a= callerDemo.caller.toString ();
alert (a);
} else {
Alert ("This are a top function");
}
}
function Handlecaller () {
Callerdemo ();
}

callee

Returns the function object being executed, which is the body of the specified function object. [function.] The Arguments.callee option function parameter is the name of the function object that is currently executing. Indicates that the initial value of the Callee property is the Function object being executed. The Callee property is a member of a arguments object that represents a reference to the function object itself, which facilitates the recursion of anonymous functions or guarantees the encapsulation of functions, such as the sum of the natural numbers of 1 to N of the following example. This property is available only if the related function is executing. It is also necessary to note that callee has the length attribute, which is sometimes used for validation or better. Arguments.length is the actual parameter length, and the arguments.callee.length is the parameter length, thus it can be judged whether the parameter length of the call is consistent with the actual parameter length.

Example

Copy Code code as follows:

Callee can print its own
function Calleedemo () {
alert (Arguments.callee);
}
Used to validate parameters
function Calleelengthdemo (arg1, arg2) {
if (arguments.length==arguments.callee.length) {
Window.alert ("Verify parameter and argument length is correct!") ");
Return
} else {
Alert ("Actual parameter length:" +arguments.length);
Alert ("Parameter length:" +arguments.callee.length);
}
}
Recursive computation
var sum = function (n) {
if (n <= 0)
return 1;
Else
return n + arguments.callee (n-1)
A more general recursive function: var sum = function (n) {
if (1==n) return 1;
else return n + sum (n-1);
}

When invoked: Alert (SUM (100));
Where the function contains a reference to sum itself, the function name is just a variable name, within the function call sum is equivalent to call a global variable, not very good to reflect the call itself, then use callee would be a better way.

Apply and call
Their role is to bind the function to another object to run, the two only in the definition of the parameters of a different way:

Apply (Thisarg,argarray);
Call (Thisarg[,arg1,arg2 ...]);

That is, the this pointer within all functions is assigned to THISARG, which enables the use of the function to run as a method of another object if the Argarray is not a valid array or is not a arguments object, then a typeerror is caused.
If you do not supply any of the Argarray and Thisarg parameters, the Global object will be used as a thisarg and cannot be passed any parameters. Call's description call method can change the object context of a function from the initial context to the new object specified by Thisarg.
If the Thisarg parameter is not provided, then the Global object is used as a thisarg-related technique: applying call and apply there is also a trick inside, after applying call and apply to another function (class), The current function (class) has a method or attribute of another function (class), which can also be referred to as "inheritance."

Look at the following example:

Copy Code code as follows:

Demo of Inheritance
function Base () {
This.member = "Dnnsun_member";
This.method = function () {
Window.alert (This.member);
}
}
function Extend () {
Base.call (this);
Window.alert (member);
Window.alert (This.method);
}

As you can see from the example above, extend can inherit the methods and properties of base after call. Incidentally, use apply in JavaScript framework prototype to create a schema that defines the class, which implements the following code:

Copy Code code as follows:

var Class = {
Create:function () {
return function () {
This.initialize.apply (this, arguments);
}
}
}

Parsing: From the code perspective, the object contains only one method: Create, which returns a function, that is, a class. But this is also the constructor of the class, which invokes initialize, which is the initialization function that is defined when the class is created. In this way, you can implement the example of the class creation pattern in prototype:

Copy Code code as follows:

var vehicle=class.create ();
vehicle.prototype={
Initialize:function (type) {
This.type=type;
}
Showself:function () {
Alert ("This vehicle is" + this.type);
}
}var moto=new vehicle ("moto");
Moto.showself ();