Can you explain how call, apply, and bind work in JavaScript?

call, apply, and bind all set what this refers to inside a function. They differ in when and how.

call and apply are interchangeable in practice — pick whichever matches how you have the args. bind is different: it produces a new function with this (and optionally leading args) locked in.

The polyfill.

Function.prototype.myBind = function (thisArg, ...partials) {
  const target = this;
  if (typeof target !== "function") {
    throw new TypeError("Bind must be called on a function");
  }

  function bound(...args) {
    // If called with `new`, ignore thisArg — `this` is the fresh instance.
    const isCtor = this instanceof bound;
    return target.apply(isCtor ? this : thisArg, [...partials, ...args]);
  }

  // Preserve prototype chain so `new boundFn()` still produces correct instances.
  if (target.prototype) {
    bound.prototype = Object.create(target.prototype);
  }
  return bound;
};

Why the new.target / instanceof check matters. The spec says: a bound function used as a constructor ignores the bound thisArg. Without that check, new BoundFn() would override the fresh instance with the bound context — instances would silently share state. Most candidate polyfills miss this.

Why preserve prototype. new boundFn() should produce something that's instanceof OriginalCtor. Linking bound.prototype to the target's prototype keeps the chain.

Partial application. bind takes args before the new function is called and prepends them on invocation:

const add = (a, b) => a + b;
const inc = add.bind(null, 1);
inc(5); // 6

This is partial application, not currying. Currying produces a chain of unary functions; bind fixes a known prefix and accepts the rest.

Common gotchas.

• bind returns a new function each time — don't addEventListener(..., fn.bind(this)) then try to removeEventListener with a freshly bound version; the reference differs.
• Arrow functions ignore bind for this — they capture lexically. bind can still set partial args, but thisArg is silently ignored.
• call/apply with null or undefined in sloppy mode coerces this to the global object; in strict mode it stays null/undefined.

When to reach for which in real code. Almost never — arrow functions and lexical this have made manual bind mostly obsolete. The two remaining uses: (1) borrowing methods (Array.prototype.slice.call(arguments), though spread does this now) and (2) partial application without a helper library.