thisArg

The value ofthis provided for the call tofunc. If the function is not instrict mode,null andundefined will be replaced with the global object, and primitive values will be converted to objects.

argsArrayOptional

An array-like object, specifying the arguments with whichfunc should be called, ornull orundefined if no arguments should be provided to the function.

The result of calling the function with the specifiedthis value and arguments.

Normally, when calling a function, the value ofthis inside the function is the object that the function was accessed on. Withapply(), you can assign an arbitrary value asthis when calling an existing function, without first attaching the function to the object as a property. This allows you to use methods of one object as generic utility functions.

You can also use any kind of object which is array-like as the second parameter. In practice, this means that it needs to have alength property, and integer ("index") properties in the range(0..length - 1). For example, you could use aNodeList, or a custom object like{ 'length': 2, '0': 'eat', '1': 'bananas' }. You can also usearguments, for example:

function wrapper() {  return anotherFn.apply(null, arguments);}

With therest parameters and parameterspread syntax, this can be rewritten as:

function wrapper(...args) {  return anotherFn(...args);}

In general,fn.apply(null, args) is equivalent tofn(...args) with the parameter spread syntax, exceptargs is expected to be an array-like object in the former case withapply(), and aniterable object in the latter case with spread syntax.

You can useArray.prototype.push() to append an element to an array. Becausepush() accepts a variable number of arguments, you can also push multiple elements at once. But if you pass an array topush(), it will actually add that array as a single element, instead of adding the elements individually, ending up with an array inside an array. On the other hand,Array.prototype.concat() does have the desired behavior in this case, but it does not append to theexisting array — it creates and returns a new array.

In this case, you can useapply to implicitly "spread" an array as a series of arguments.

const array = ["a", "b"];const elements = [0, 1, 2];array.push.apply(array, elements);console.info(array); // ["a", "b", 0, 1, 2]

The same effect can be achieved with the spread syntax.

const array = ["a", "b"];const elements = [0, 1, 2];array.push(...elements);console.info(array); // ["a", "b", 0, 1, 2]

Clever usage ofapply() allows you to use built-in functions for some tasks that would probably otherwise require manually looping over a collection (or using the spread syntax).

For example, we can useMath.max() andMath.min() to find out the maximum and minimum value in an array.

// min/max number in an arrayconst numbers = [5, 6, 2, 3, 7];// using Math.min/Math.max applylet max = Math.max.apply(null, numbers);// This about equal to Math.max(numbers[0], …)// or Math.max(5, 6, …)let min = Math.min.apply(null, numbers);// vs. loop based algorithmmax = -Infinity;min = Infinity;for (const n of numbers) {  if (n > max) {    max = n;  }  if (n < min) {    min = n;  }}

But beware: by usingapply() (or the spread syntax) with an arbitrarily long arguments list, you run the risk of exceeding the JavaScript engine's argument length limit.

The consequences of calling a function with too many arguments (that is, more than tens of thousands of arguments) is unspecified and varies across engines. (The JavaScriptCore engine has a hard-codedargument limit of 65536.) Most engines throw an exception; but there's no normative specification preventing other behaviors, such as arbitrarily limiting the number of arguments actually passed to the applied function. To illustrate this latter case: if such an engine had a limit of four arguments (actual limits are of course significantly higher), it would be as if the arguments5, 6, 2, 3 had been passed toapply in the examples above, rather than the full array.

If your value array might grow into the tens of thousands, use a hybrid strategy: apply your function to chunks of the array at a time:

function minOfArray(arr) {  let min = Infinity;  const QUANTUM = 32768;  for (let i = 0; i < arr.length; i += QUANTUM) {    const subMin = Math.min.apply(      null,      arr.slice(i, Math.min(i + QUANTUM, arr.length)),    );    min = Math.min(subMin, min);  }  return min;}const min = minOfArray([5, 6, 2, 3, 7]);

• arguments
• Function.prototype.bind()
• Function.prototype.call()
• Reflect.apply()
• Functions
• Spread syntax (...)