Detailed code explanation of JavaScript's call method, apply method, caller attribute, and callee attribute

js call method_apply method_caller attribute_callee attribute

1. call method
Call a method of an object , replace the current object with another object (actually changing the internal pointer of the object, that is, changing the content pointed to by this of the object).

Js code

call([thisObj[,arg1[, arg2[,   [,.argN]]]]])

Parameters
thisObj
Optional. The object that will be used as the current object.
arg1, arg2, , argN
Optional. A sequence of method parameters will be passed.
Description
The call method can be used to call a method instead of another object. The call method changes the object context of a function from the initial context to the new object specified by thisObj. If no thisObj parameter is provided, the Global object is used as thisObj.

Js code

<input type=“text”id=“myText”value=“input text”>
<script>
functionObj(){this.value=“对象！”;}
varvalue=“global 变量”;
functionFun1(){alert(this.value);}

window.Fun1();   //global 变量
Fun1.call(window);  //global 变量
Fun1.call(document.getElementByIdx_x_x(‘myText’));//input text
Fun1.call(new Obj());//对象！
</script>

Js code

varfirst_object = {
num: 42
};
varsecond_object = {
num: 24
};
functionmultiply(mult) {
returnthis.num * mult;
}
multiply.call(first_object, 5); // returns 42 * 5
multiply.call(second_object, 5); // returns 24 * 5

2. Apply method
The first parameter of the apply method must also be passed in to the current The object of the object, that is, this inside the function. The following parameters are the parameters passed to the current object.
The functions of apply and call are the same, but they are different in parameters. The meaning of the first parameter is the same, but for the second parameter: apply passes in a parameter array, that is, multiple parameters are combined into an array and passed in, while call is passed in as the parameter of call (from the starting with two parameters).
For example, the corresponding apply writing method of func.call(func1,var1,var2,var3) is: func.apply(func1,[var1,var2,var3]). The advantage of using apply at the same time is that you can directly apply the arguments object of the current function. Passed in as the second parameter of apply.

Js code

var func=newfunction(){this.a=“func”}
varmyfunc=function(x,y){
vara=“myfunc”;
alert(this.a);
alert(x + y);
}
myfunc.call(func,“var”,“ fun”);// ”func” ”var fun”
myfunc.apply(func,["var"," fun"]);// ”func” ”var fun”

3. Caller attribute
Returns a reference to the function, that is, the function body of the current function is called.
functionName.caller :functionName object is the name of the executed function.
Note:
For functions, the caller attribute is only defined when the function is executed. If the function is called from the top level of a JScript program, then 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.

Js code

<script>
functionCallLevel(){
if(CallLevel.caller ==null)
alert(“CallLevel was called from the top level.”);
else
alert(“CallLevel was called by another function:\n”+CallLevel.caller);
}
functionfunCaller(){
CallLevel();
}
CallLevel();
funCaller()
</script>

4. callee attribute
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.
Description:
The initial value of the callee attribute is the Function object being executed.
The callee attribute is a member of the arguments object. It represents a reference to the function object itself. This is helpful for hiding the recursion of the
function or ensuring the encapsulation of the function. For example, the following example recursively calculates the natural numbers from 1 to n. and. This attribute
is only available when the relevant function is executing. It should also be noted that callee has a length attribute, which is sometimes better used for verification. arguments.length is the actual parameter length, and arguments.callee.length is the
formal parameter length. From this, you can determine whether the formal parameter length is consistent with the actual parameter length during the call.

//callee可以打印其本身
functioncalleeDemo() {
alert(arguments.callee);
}
//用于验证参数
functioncalleeLengthDemo(arg1, arg2) {
if(arguments.length==arguments.callee.length) {
window.alert(“验证形参和实参长度正确！”);
return;
} else{
alert(“实参长度：”+arguments.length);
alert(“形参长度： ”+arguments.callee.length);
}
}
//递归计算
var sum =function(n){
if(n <= 0)
return 1;
else
returnn ＋arguments.callee(n - 1)
}

5. bind

<script type=“text/javascript”>
varfirst_object = {
num: 42
};
varsecond_object = {
num: 24
};

functionmultiply(mult) {
returnthis.num * mult;
}

Function.prototype.bind = function(obj) {
var method =this,
temp = function() {
returnmethod.apply(obj, arguments);
};

return temp;
}

varfirst_multiply = multiply.bind(first_object);
first_multiply(5); // returns 42 * 5

varsecond_multiply = multiply.bind(second_object);
second_multiply(5); // returns 24 * 5
</script>

The above is the detailed content of Detailed code explanation of JavaScript's call method, apply method, caller attribute, and callee attribute. For more information, please follow other related articles on the PHP Chinese website!