Implementing Function.prototype.apply from scratch

apply is identical to call except arguments arrive as a single array rather than individually. All the this binding logic is the same.

Implementation

Open in editorCopy
Function.prototype.myApply = function (context, args) {
  context = context === null || context === undefined ? globalThis : Object(context);

  const fnKey = Symbol("fn");
  context[fnKey] = this;

  const result = Array.isArray(args) ? context[fnKey](...args) : context[fnKey]();

  delete context[fnKey];
  return result;
};

Key difference from call

The only new piece: handle the args parameter safely.

• If args is an array → spread it: context[fnKey](...args)
• If args is omitted or not an array → call with no arguments: context[fnKey]()

The native apply also accepts array-like objects (anything with .length). For an interview, Array.isArray is enough — just say "the real apply also handles array-likes via Array.from, I've kept this simple for clarity."

Classic use case

Open in editorCopy
// Apply a variadic function to an array of values
const numbers = [3, 1, 4, 1, 5, 9];
Math.max.myApply(null, numbers); // 9

// Before spread syntax, this was the standard way to do it
// Now you'd write Math.max(...numbers)

Edge cases to mention

• Same context handling as call: null/undefined → globalThis, primitives → Object()
• Same Symbol-key cleanup
• args being null is valid — treat same as omitted (no arguments)