javascript

Chapter 5: Reference Types
In this example, callSum1() executes the sum() method, passing in this as the scope (which is equal
to window because it ’ s being called in the global scope) and also passing in the arguments object. The
callSum2() method also calls sum(), but it passes in an array of the arguments instead. Both functions
will execute and return the correct result.
The call() method exhibits the same behavior as apply() , but arguments are passed to it differently.
The first argument is the scope, but the remaining arguments are passed directly into the function. Using
call() , arguments must be enumerated specifically, as in this example:
function sum(num1, num2){
return num1 + num2;
}
function callSum(num1, num2){
return sum.call(this, num1, num2);
}
alert(callSum(10,10)); //20
Using the call() method, callSum() must pass in each of its arguments explicitly. The result is the
same as using apply() . The decision to use either apply() or call() depends solely on the easiest
way for you to pass arguments into the function. If you intend to pass in the arguments object directly
or if you already have an array of data to pass in, then apply() is the better choice; otherwise, call()
may be a more appropriate choice. (If there are no arguments to pass in, these methods are identical.)
The true power of apply() and call() lies not in their ability to pass arguments, but rather in their
ability to augment the scope in which a function runs. Consider the following example:
window.color = “red”;
var o = { color: “blue” };
function sayColor(){
alert(this.color);
}
sayColor();
//red
sayColor.call(this); //red
sayColor.call(window); //red
sayColor.call(o); //blue
This example is a modified version of the one used to illustrate the this object. Once again, sayColor()
is defined as a global function, and when it ’ s called in the global scope, it displays “ red ” because this
.color evaluates to window.color . You can then call the function explicitly in the global scope by
using sayColor.call(this) and sayColor.call(window) , which both display “ red ” . Running
sayColor.call(o) switches the context of the function such that this points to o , resulting in a
display of “ blue ” .
The advantage of using call() (or apply() ) to augment the scope is that the object doesn ’ t need to know
anything about the method. In the first version of this example, the sayColor() function was placed
directly on the object o before it was called; in the updated example, that step is no longer necessary.
129