https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/apply
The apply()
method calls a function with a given this
value, and arguments
provided as an array (or an array-like object).
Note: While the syntax of this function is almost identical to that of call()
, the fundamental difference is that call()
accepts an argument list, while apply()
accepts a single array of arguments.
function
.apply(thisArg, [argsArray])
thisArg
this
provided for the call tofunc
. Note thatthis
may not be the actual value seen by the method: if the method is a function in non-strict mode code,null
andundefined
will be replaced with the global object, and primitive values will be boxed. This argument is not optional argsArray
func
should be called, ornull
orundefined
if no arguments should be provided to the function. Starting with ECMAScript 5 these arguments can be a generic array-like object instead of an array. See below for browser compatibility information. The result of calling the function with the specified this
value and arguments.
You can assign a different this
object when calling an existing function. this
refers to the current object, the calling object. With apply
, you can write a method once and then inherit it in another object, without having to rewrite the method for the new object.
apply
is very similar to call()
, except for the type of arguments it supports. You use an arguments array instead of a list of arguments (parameters). With apply
, you can also use an array literal, for example, func.apply(this, [‘eat‘, ‘bananas‘])
, or an Array
object, for example, func.apply(this, new Array(‘eat‘, ‘bananas‘))
.
You can also use arguments
for the argsArray
parameter. arguments
is a local variable of a function. It can be used for all unspecified arguments of the called object. Thus, you do not have to know the arguments of the called object when you use the apply
method. You can use arguments
to pass all the arguments to the called object. The called object is then responsible for handling the arguments.
Since ECMAScript 5th Edition you can also use any kind of object which is array-like, so in practice, this means it‘s going to have a property length
and integer properties in the range (0..length-1)
. As an example you can now use a NodeList
or a custom object like { ‘length‘: 2, ‘0‘: ‘eat‘, ‘1‘: ‘bananas‘ }
.
Most browsers, including Chrome 14 and Internet Explorer 9, still do not accept array-like objects and will throw an exception.
apply
to append an array to another SectionWe can use push
to append an element to an array. And, because push
accepts a variable number of arguments, we can also push multiple elements at once. But, if we pass an array to push
, it will actually add that array as a single element, instead of adding the elements individually, so we end up with an array inside an array. What if that is not what we want? concat
does have the behaviour we want in this case, but it does not actually append to the existing array but creates and returns a new array. But we wanted to append to our existing array... So what now? Write a loop? Surely not?
apply
to the rescue!
var array = [‘a‘, ‘b‘]; var elements = [0, 1, 2]; array.push.apply(array, elements); console.info(array); // ["a", "b", 0, 1, 2]
With the apply()
method, you can write a method that can be used on different objects.
The apply()
method is similar to the call()
method (previous chapter).
In this example the fullName method of person is applied on person1:
var person = { fullName: function() { return this.firstName + " " + this.lastName; }}var person1 = { firstName: "Mary", lastName: "Doe"}person.fullName.apply(person1); // Will return "Mary Doe"
The difference is:
The call()
method takes arguments separately.
The apply()
method takes arguments as an array.
The apply() method is very handy if you want to use an array instead of an argument list.
The apply()
method accepts arguments in an array:
var person = { fullName: function(city, country) { return this.firstName + " " + this.lastName + "," + city + "," + country; }}var person1 = { firstName:"John", lastName: "Doe"}person.fullName.apply(person1, ["Oslo", "Norway"]); //这里是一个array参数
Compared with the call()
method:
var person = { fullName: function(city, country) { return this.firstName + " " + this.lastName + "," + city + "," + country; }}var person1 = { firstName:"John", lastName: "Doe"}person.fullName.call(person1, "Oslo", "Norway"); //这里是2个参数