Home > Article > Web Front-end > Understand arguments, callee, caller, apply in JavaScript
Understand arguments, callee, caller, apply in JavaScript
- 高洛峰Original
- 2016-12-14 09:59:32941browse
arguments
This object represents the parameters of the function being executed and the function that calls it.
[function.]arguments[n]
Parameters function: options. The name of the Function object currently executing. n: option. The 0-based index of the parameter value to be passed to the Function object.
Explanation
Arguments is a hidden object created in addition to the specified parameters when calling a function. Arguments is an object that is similar to an array but not an array. It is similar to an array because it has the same access properties and methods as an array. The value of the corresponding single parameter can be accessed through arguments[n], and it has the array length attribute length. Also, the arguments object stores the parameters actually passed to the function, not limited to the parameter list defined by the function declaration, and the arguments object cannot be created explicitly. The arguments object is only available at the beginning of the function.
<html>
<head><title>test-apply&call</title></head>
<body>
<script type="text/javascript">
//<![CDATA[
function ArgTest(a, b){
var i, s = "The ArgTest function expected ";
var numargs = arguments.length;arguments.length即为这个函数调用时所带的参数数量 // 获取被传递参数的数值。 //ArgTest('a','b')：numargs=2， expargs=2
var expargs = ArgTest.length;;ArgTest.length为函数规定的参数数量 // 获取期望参数的数值。//ArgTest('a','b','c')：numargs=3， expargs=2
if (expargs < 2)
s += expargs + " argument. ";
else
s += expargs + " arguments. ";
if (numargs < 2)
s += numargs + " was passed.";
else
s += numargs + " were passed.";
s += "/n/n"
for (i =0 ; i < numargs; i++){ // 获取参数内容。
s += " Arg " + i + " = " + arguments[i] + "/n";;arguments类似数组 可通过arguments[ ]进行取得各个参数值
}
return(s); // 返回参数列表。
}
window.document.write(ArgTest('aaa', 'bbbb','cccc','dddd'));
//]]>
</script>caller [Summoner]
Returns a reference to the function that called the current function.
functionName.caller
The functionName object is the name of the executed function.
Explanation
For functions, the caller attribute is only defined when the function is executed. If the function is called from the top level, caller contains null . If the caller attribute is used in a string context, the result is the same as functionName.toString, that is, the decompiled text of the function is displayed.
The following example illustrates the usage of the caller attribute: // caller demo {
function callerDemo() {
if (callerDemo.caller) {
var a= callerDemo.caller.toString();
alert(a);
} else {
alert("this is a top function");
}
}
function handleCaller() {
callerDemo();
}handleCaller(), returns function handleCaller() { callerDemo();} [that is, callerDemo() returns the function itself that calls it String form], if callerDemo() is run directly, function anonymous(){callerDemo();}
callee
returns the Function object being executed, which is the body of the specified Function object. [function.]arguments.callee optional function parameter is the name of the Function object currently being executed. Note that the initial value of the callee attribute is the Function object being executed. The callee attribute is a member of the arguments object, which represents a reference to the function object itself. This is beneficial to the recursion of anonymous functions or to ensure the encapsulation of the function. For example, the following example recursively calculates the sum of natural numbers from 1 to n. And this property
is only available when the relevant function is executing. It should also be noted that callee has a length attribute, which is sometimes better for verification. arguments.length is the actual parameter length, and arguments.callee.length is the formal parameter length. From this, we can determine whether the formal parameter length is consistent with the actual parameter length when calling. Example //callee can print itself
function calleeDemo() {
alert(arguments.callee);
}
//calleeDemo() 就返回calleeDemo() 函数本身的String形式：function calleeDemo() { alert(arguments.callee);}
//用于验证参数
function calleeLengthDemo(arg1, arg2) {
if (arguments.length==arguments.callee.length) {
window.alert("验证形参和实参长度正确！");
return;
} else {
alert("实参长度：" +arguments.length);//实际使用calleeLengthDemo(arg1, arg2)函数所带的参数:calleeLengthDemo('a') 则实参为1
alert("形参长度： " +arguments.callee.length);//calleeLengthDemo(arg1, arg2)函数所定义的参数数:2
}
}
//递归计算
var sum = function(n){
if (n <= 0)
return 1;
else
return n + arguments.callee(n - 1)// arguments.callee调用当前正在执行的函数，即sum本身！
}比较一般的递归函数：var sum = function(n){
if (1==n) return 1;
else return n + sum (n-1);
}调用时：alert(sum(100));The function contains a reference to sum itself. The function name is just a variable name. Calling sum inside the function is equivalent to calling
a global variable, which cannot be reflected well. Otherwise, it is to call itself. In this case, using callee would be a better method. callee can print itself
call and apply
That is, the this pointer inside all functions will be assigned to thisArg, which can realize the purpose of running the function as a method of another object
Instructions for apply if argArray is not a valid array or is not an arguments object, a TypeError will result.If neither argArray nor thisArg is provided, the Global object will be used as thisArg,
and no parameters can be passed.
Description of call The 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, the Global object is used as thisArg. Related tips: There is another trick in applying call and apply. After using call and apply to apply another function (class), the current
function (class) will be Having methods or properties of another function (class) can also be called "inheritance". Look at the following example: Demonstration 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);
}//After calling extend(), window.alert(member)=》dnnsun_Member; window.alert(this.method)=》function (){window.alert(this .menber);}
As can be seen from the above example, extend can inherit the methods and properties of base after calling. By the way, apply is used in the JavaScript framework prototype to create a pattern that defines a class. The implementation code is as follows:
var Class = {
create: function() {
return function() {
this.initialize.apply(this, arguments);
}
}} Analysis: From the code point of view, the object only contains one method: Create, which returns a function, That is the category. But this is also the
constructor of the class, which calls initialize, and this method is the initialization function defined when the class is created. In this way, can realize the class creation mode example in prototype: 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();