Call vs invoke in JavaScript (meaning, this, tested output)

In everyday English people mix the words call and invoke, and blog posts sometimes imply they are different ECMAScript operators. In the language itself both words describe the same idea: a function’s body runs with a specific set of arguments and a resolved this binding. What actually changes behavior is the call form you choose—fn(), obj.method(), fn.call(ctx), new Constructor(), and so on—because those forms set this, new.target, and strict-mode rules, not the vocabulary in your comment.

This page clears up that vocabulary, shows this on a normal method call versus Function.prototype.call, and disambiguates the .call() method name from “calling a function.” All fenced text output below is stdout from Node.js for the snippet above each block.

Tested on: all examples in this tutorial were run with Node.js v20.18.2, and the output shown below each snippet is its exact console output.

Quick reference

Use this table for invoke vs call in programming when reading JavaScript docs.

1. “Calling” and “invoking” are usually synonyms

If you invoke a function or call a function, you are scheduling it to execute with arguments and producing a return value (or undefined). Docs and blogs pick one word for style; there is no hidden second mechanism in the engine keyed off the English word invoke alone.

2. Direct call: add(5, 10)

function add(arg1, arg2) {
  return arg1 + arg2;
}

const result = add(5, 10);
console.log(result);

15

3. Method call: this comes from the call form, not from the word “invoke”

arr.push(34) is still a function call. push runs with this set to arr because you used property access (object.method()), not because the operation is called an “invoke” in prose.

const arr = [1, 34, 212, 12];

arr.push(34);

console.log(arr);

[ 1, 34, 212, 12, 34 ]

For invoke vs call in programming interviews, the teaching point in JavaScript is how you accessed the function (free call vs method call vs .call/.apply/.bind/constructor call), not the verb you use in English.

4. Explicit this with Function.prototype.call (the method named call)

This is the usual confusion: fn.call(obj, 1, 2) uses the .call method to run fn with this === obj. That is still one function execution—you are not switching from a “call” to a different magical “invoke” mode.

const o = { x: 1, getX() { return this.x; } };
const p = { x: 99 };

console.log(o.getX());
console.log(o.getX.call(p));

1
99

The first line uses this === o. The second uses call so getX runs with this === p.

5. js invoke in APIs (not the language core)

Some libraries expose a method literally named invoke (for example collection helpers). That is a library identifier, not proof that the JavaScript engine distinguishes “invoke” from “call” in grammar.

6. Related reading on this site

• Functions as values — how storing functions relates to later calling them.
• Arrow functions — lexical this and why call-site rules differ from ordinary functions.

Summary

• “Call” and “invoke” in prose both mean executing a function body in JavaScript.
• this follows call-site rules (obj.m(), m.call(ctx), new, arrows), not vocabulary.
• Function.prototype.call is an API for explicit this; it is not a separate “invoke” opcode.

References

MDN guides for functions, this, and Function.prototype.call.

• MDN: Functions
• MDN: Function.prototype.call()
• MDN: this