Calling vs invoking a function

Question

Up to this point, I thought \"calling\" and \"invoking\" a function meant the same thing. However, in a YouTube tutorial it said to invoke a function by calling it.

Answer 1

Many people use the term calling and invoking interchangeably but that's not right. There is a very slight difference between calling and invoking a function. In JavaScript functions can be invoked without being called which means that the code inside the body of the function can be executed without creating an object for the same. It is tied to the global object. When there is no individual object, the value of this is associated with the global object.

There is also a difference between call and apply, the fundamental difference is that call() accepts an argument list, while apply() accepts a single array of arguments. A different this object can be assigned when calling an existing function. this refers to the current object, the calling object. With call, you can write a method once and then inherit it in another object, without having to rewrite the method for the new object.

So, the major difference between invoking and calling comes in terms of the this object. Calling let's you set the this value whereas invoking just ties it to the global object.

Answer 2

Your reference text:

It is common to use the term "call a function" instead of "invoke a function" ... In this tutorial, we will use invoke, because a JavaScript function can be invoked without being called.

Now let me rephrase it:

It is common to use the term "call a function" instead of "invoke a function" ... In this tutorial, we will use the term invoke instead of call, because a JavaScript function can be invoked indirectly like fn.call() and fn.apply() without being called directly like fn().

So, when I do fn(), it's invoked directly and when I do it like fn.call(), it's invoked indirectly but in both cases, the function is being invoked. Otherwise, I see no difference here and I can also say that I can call a function in many ways, for example:

fn(); // I'm calling it
fn.call(); // I'm calling it
fn.apply(); // I'm calling it

So, the difference is semantic but both are interchangeable, IMO. BTW, I wrote a comment above, under the question and I would like to put it here, which is:

IMO, that's a misleading statement. Maybe there are some indication of call/apply or something else but it's totally confusing.

Answer 3

The difference is semantic and subtle. When you call a function, you are directly telling it to run. When you invoke a function, you are letting something run it.

There is one way to call a function:

myFunction()

Here, you are invoking the function (letting it run) by calling it directly.

There are many ways to invoke a function (given throughout different comments and answers). Here's one example:

function invoker(functionName) {
  functionName() 
}

invoker(myFunction)

Here, by calling invoker, you are invoking myFunction, which is being called indirectly.

Answer 4

Yes, in most cases we use both to refer the execution of a function.

There are 2 ways to reach place B from your HOME.

1. Direct/Automatic way (Invoke), i.e. if you choose first way, you do not need to walk. Someone will automatically take you to place B.
2. Indirect way (Call), i.e. if choose second way, you only need to reach A(by walk). Someone is there at place A to automatically take you to place B.

Have a look at the below image. I think it will clear your doubt.

In case of Calling, you originally refer to the statement that actually calls the function.

In case of Invoking, you indirectly refer to calling statement to actually invoke/run the function.

Answer 5

"function invoked" means a function got executed

"function called" means that a function was called by another function and then executed

"function invoked without being called" is a function that got self invoked without being called by another function

example of a self invoking function calling another function:
var f = (function() { 
   foo();
})();  ///() here means it self invoked -- without being called directly.

var foo = (function() {
    ///Do something here
});