.call() executes the function immediately and passes the parameters one by one, .apply() executes immediately but passes the parameters in an array, .bind() returns a new function that binds this and is not executed immediately. All three are used to control this pointing inside the function. .call() is suitable for method borrowing and explicit parameter passing, .apply() is suitable for parameter arrays or uncertain numbers, and .bind() is used to create reusable functions with preset parameters and contexts, and this cannot be changed after binding.

In JavaScript, .call() , .apply() , and .bind() are all used to control the value of this inside a function. While they serve similar purposes, they differ in how they're used and when you should reach for each one.

What .call() Does

.call() lets you call a function with a specific this context and pass arguments one by one .

This is useful when you want to immediately invoke a function but make sure it runs in a particular object context.

For example:

 function greet(greeting, punctuation) {
  console.log(greeting ', ' this.name punctuation);
}

const person = { name: 'Alice' };

greet.call(person, 'Hello', '!'); // Logs: Hello, Alice!

Key points:

• Invokes the function immediately
• Arguments are passed individually after the this context
• Good for borrowing methods from other objects

How .apply() Is Different

.apply() works just like .call() , but instead of listing arguments out, it takes them as an array (or array-like) structure.

This becomes handy when you don't know how many arguments there will be ahead of time, or if you already have them in an array.

Example:

 greet.apply(person, ['Hi', '!!!']); // Logs: Hi, Alice!!!

Use .apply() when:

• You have an array of arguments ready
• You want to pass variable-length arguments easily
• It's common in older codebases for things like Math.max.apply(null, array)

When to Use .bind()

Unlike .call() and .apply() , .bind() doesn't call the function right away . Instead, it returns a new function with the this value set permanently.

This is especially useful for callbacks where you need to preserve the context later on.

Example:

 const greetPerson = greet.bind(person, 'Hey');
greetPerson('?'); // Logs: Hey, Alice?

Why you'd use .bind() :

• To create a reusable function with preset arguments
• To avoid losing this context in events or timeouts
• Once bound, the this can't be changed again — it's locked in

Quick Comparison Summary

• .call() → immediate execution, arguments listed
• .apply() → immediate execution, arguments in an array
• .bind() → returns a new function, doesn't execute right away

You'll often see these used when working with object methods, event handlers, or when trying to borrow functionality between objects.

Basically that's it.

The above is the detailed content of Differences Between .call(), .apply(), and .bind() in JavaScript. For more information, please follow other related articles on the PHP Chinese website!