thisArg

The value to use asthis when callingfunc. If the function is not instrict mode,null andundefined will be replaced with the global object, and primitive values will be converted to objects.

arg1, …,argNOptional

Arguments for 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. Withcall(), 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.

In the example below, when we callgreet, the value ofthis will be bound to objectobj, even whengreet is not a method ofobj.

function greet() {  console.log(this.animal, "typically sleep between", this.sleepDuration);}const obj = {  animal: "cats",  sleepDuration: "12 and 16 hours",};greet.call(obj); // cats typically sleep between 12 and 16 hours

If the firstthisArg parameter is omitted, it defaults toundefined. In non-strict mode, thethis value is then substituted withglobalThis (which is akin to the global object).

globalThis.globProp = "foo";function display() {  console.log(`globProp value is ${this.globProp}`);}display.call(); // Logs "globProp value is foo"

In strict mode, the value ofthis is not substituted, so it stays asundefined.

"use strict";globalThis.globProp = "foo";function display() {  console.log(`globProp value is ${this.globProp}`);}display.call(); // throws TypeError: Cannot read the property of 'globProp' of undefined

call() is almost equivalent to a normal function call, except thatthis is passed as a normal parameter instead of as the value that the function was accessed on. This is similar to how general-purpose utility functions work: instead of callingarray.map(callback), you usemap(array, callback), which allows you to usemap with array-like objects that are not arrays (for example,arguments) without mutatingObject.prototype.

TakeArray.prototype.slice(), for example, which you want to use for converting an array-like object to a real array. You could create a shortcut like this:

const slice = Array.prototype.slice;// …slice.call(arguments);

Note that you can't saveslice.call and call it as a plain function, because thecall() method also reads itsthis value, which is the function it should call. In this case, you can usebind() to bind the value ofthis forcall(). In the following piece of code,slice() is a bound version ofFunction.prototype.call(), with thethis value bound toArray.prototype.slice(). This means that additionalcall() calls can be eliminated:

// Same as "slice" in the previous exampleconst unboundSlice = Array.prototype.slice;const slice = Function.prototype.call.bind(unboundSlice);// …slice(arguments);

• Function.prototype.bind()
• Function.prototype.apply()
• Reflect.apply()
• Spread syntax (...)
• Introduction to Object-Oriented JavaScript