The methods call, bind, and apply exist to supplement the relationship between a function and the scope of this inside the function at execution time. this is undefined in a function, due its execution context, when the function is not aware of the object from which the function is called. When that does happen this resolves up the scope chain until it reaches an object in global scope, typically window in the browser. The three methods allow a developer to manually define the execution context of a function so that this is bound to the context of the stated object. This problem more commonly occurs due to OOP programming patterns and the developers misunderstanding between scope and inheritance. Personally, I couldn't tell you the difference between the three methods without having to look them up because I never use them. I have stated exactly this during job interviews in the past. Never having to use these three methods is blessing that comes from avoiding inheritance in this language and/or only associating inheritance with event execution. These methods are a hacky work around that complicates the understanding of code from a high level. I understand that there are many people who need these because they absolutely cannot imaging programming without inheritance. That is unfortunately the world we live in. More on reddit.com

What is the difference between JavaScript’s `apply` and `call` methods · When invoking a function like func.apply() versus func.call(), how do these two differ in handling arguments? Are there any performance differences between them, and when should you prefer using call over apply or vice ... More on community.testmuai.com

The basic idea behind call/apply/bind is the same: explicitly set function parameters including this. The context changes a bit, but the use cases will all be niche instances when the normal ways of setting function parameters (i.e. placing them between the parentheses or to the left of the dot for this) are not sufficient. Apply First, apply. You will almost certainly never need apply. Why? Because the common use case has been supplanted by a new syntax: the spread operator (...). In the past, if you had your parameters in an array, apply was the way to get them into a function. const nums = [1, 2, 3]; const largest = Math.max.apply(null, nums); console.log(largest); // 3 These days, spread is easier to write and read. const nums = [1, 2, 3]; const largest = Math.max(...nums); console.log(largest); // 3 Call Okay, call works a lot like just, well, calling a function. The only difference is that the this moves from the left of the dot to the first parameter between the parentheses. const nums = [1, 2, 3]; console.log(nums.includes(2)); // true console.log(Array.prototype.includes.call(nums, 2)); // true When is this useful? Mostly never. Cases occasionally come up. Sometimes you want to call one object's method on a different object. Call lets you do that. It is always very technical and niche. Bind Bind is probably the most useful of the three, which isn't saying much. It allows you to pass parameters to a function before you call it, creating a new function with those parameters baked in. const nums = [1, 2, 3]; const numsIncludesThree = Array.prototype.includes.bind(nums, 3); console.log(numsIncludesThree()); // true nums.pop(); console.log(numsIncludesThree()); // false This is kind of neat. It allows you to build up functions out of parameters, and is related to awesome concepts like "partially applying" functions, "factory" functions, and "currying". That said, you don't actually see bind used all that often. It is clunky compared to other options like lodash's partial , and most people who write code like this also religiously avoid using this, which will always be the first parameter bind takes. For awhile it was common to see people use bind in their class definitions: class User { constructor(name) { this.name = name; this.greet = this.greet.bind(this); } greet() { console.log(`Hello, ${this.name}!`); } } This allows you to use your class method in circumstances where the this would not be set, for example as a callback to another function like an event listener or setTimeout. const user = new User('Sue'); setTimeout(user.greet, 1000); // Hello, Sue! This approach has mostly fallen out of fashion though. Using bind in the constructor is just fighting the way JS works because you wish it worked like a different language, people don't even use classes all that often anymore, and there are more straightforward ways to accomplish the same behavior. setTimeout(() => { user.greet(); }, 1000); // Hello, Sue! (no bind required) TLDR If you need them, you'll know. But you mostly won't. More on reddit.com

call calls a function with individual arguments:

fn.call( thisArg, 1, 2, 3 );      // fn( 1, 2, 3 ); with `this` in fn set to `thisArg`

apply calls a function with an array of arguments:

fn.apply( thisArg, [ 1, 2, 3 ] ); // fn( 1, 2, 3 ); with `this` in fn set to `thisArg`

bind doesn't call the function at all, but binds scope and arguments to a function so that when you call the resulting function the original one is called:

var newFn = fn.bind( thisArg, 1, 2, 3 ); // fn doesn't run yet
newFn();    // calls fn.call( thisArg, 1, 2, 3 );
newFn( 4 ); // calls fn.call( thisArg, 1, 2, 3, 4 );

So call vs apply just comes down to how you have your data (well that and call is much faster). Use bind when you want to do something later

More on reddit.com