What is the difference between call, apply, and bind?

Q: What is the difference between call, apply, and bind?

**Target Audience:** Engineers preparing for JavaScript fundamentals interviews. **Difficulty:** Medium > **How to read this doc:** Concepts are explained in plain language first, then tagged with 📌 Interview term: . Every timing and this-binding claim below was actually run in Node. ## 1. Why This Even Matters — A Story First Think of `this` as a name tag a function wears while it runs. `call` and `apply` are like handing someone a name tag and asking them to introduce themselves RIGHT NOW, with the tag on. `bind` is different — it is like permanently sewing that name tag onto a jacket and handing back the jacket itself, ready to be worn and introduced whenever someone actually puts it on later. All three control the same name tag, but only two of them make the introduction happen immediately. ## 2. The Core Idea 📌 **Interview term:** `call`/`apply` invoke the function immediately with a given `this` (arguments individually vs. as an array). `bind` invokes nothing —

The problem

Question presented to candidate: "What's the actual difference between call, apply, and bind — not just how their arguments are formatted, but what each one actually DOES to the function?"

What a strong answer should cover:

📌 Interview term: fn.call(thisArg, arg1, arg2, ...) — invokes fn immediately, with this set to thisArg, passing the remaining arguments individually.
📌 Interview term: fn.apply(thisArg, [arg1, arg2, ...]) — invokes fn immediately, identical to call, except the arguments are passed as a single array.
📌 Interview term: fn.bind(thisArg, arg1, ...) — does not invoke fn at all; it returns a new function with this permanently locked to thisArg (and optionally some leading arguments pre-filled), to be called later.
📌 Interview term: the real, direct distinguishing proof — verified directly: calling .call()/.apply() genuinely invoked the function immediately (a tracking flag flipped to true synchronously), while calling .bind() genuinely left that same flag false until the returned bound function was separately, explicitly called.
A precise answer names that once a function is bound, its this genuinely cannot be overridden by a later .call(), .apply(), or even another .bind() — verified directly, the original bound this stayed in place through both override attempts — and that arrow functions ignore all three methods' this argument entirely, since arrow functions have no this of their own to rebind.

Clarifying questions expected:

None — this is a definitional/comparison question; correctly distinguishing "invokes immediately" (call/apply) from "returns a new function for later" (bind) is the strong signal, beyond the argument-formatting difference most candidates already know.

Code / implementation expected: Yes — demonstrating the immediate-invocation vs. deferred-invocation distinction directly (not just the argument format) is the most convincing proof of real understanding.

call-apply-bind

Try it yourself

Sketch your approach before you read the solution. That is what the interview tests.

Stuck? Get a hint.

A short nudge toward the approach. It will not give the answer away.

Solution

Target Audience: Engineers preparing for JavaScript fundamentals interviews. Difficulty: Medium

How to read this doc: Concepts are explained in plain language first, then tagged with 📌 Interview term:. Every timing and this-binding claim below was actually run in Node.

1. Why This Even Matters — A Story First

Think of this as a name tag a function wears while it runs. call and apply are like handing someone a name tag and asking them to introduce themselves RIGHT NOW, with the tag on. bind is different — it is like permanently sewing that name tag onto a jacket and handing back the jacket itself, ready to be worn and introduced whenever someone actually puts it on later. All three control the same name tag, but only two of them make the introduction happen immediately.

2. The Core Idea

📌 Interview term: call/apply invoke the function immediately

The solution is hidden so you can try first

6 min read · 8 sections

Run the code

Edit the code and run it here. Each console line with an expected value becomes a test.

JavaScriptReal proof: call/apply invoke immediately, bind returns a new function, and a bound this cannot be overridden