Is this an anonymous function?

Question

In the first snippet below, based on my understanding I am creating a function and assigning it to a variable. But does that mean the function will take that name of the variable ?

var aFunc = function(){};

I know this is named function.

function bFunc(){};

Answer 1

So, first of all we have to clarify the main difference between the two functions you wrote.

This one:

var aFunc = function(){};

is a function expression. Where this one:

function bFunc(){};

is a function declaration.

In a function expression you're using the function operator to defines a function inside an expression. When you declare a function you're using the function statement.

At the beginning it can be confusing because they're really similar, however function declaration and function expression behaves differently. First of all, you can't declare a function that is anonymous: if you're using a function statement, the name is mandatory. So only functions defined with the function operator can be anonymous:

var aFunc = function(){};

That's an anonymous function. In some browsers you can actually print the function's name and see by yourself:

console.log(aFunc.name); 

(Notice that this is not standard yet, but there is a proposal)

But it doesn't means that functions declared with the function operator have to be anonymous. For instance:

var aFunc = function myFunction() {};

It's a named function. However, that's still different from having a function declaration like that:

function myFunction() {};
var aFunc = myFunction;

Why? Because in case of function expression, you don't declare a myFunction function in the scope:

var aFunc = function myFunction() {};

console.log(typeof myFunction) // undefined, unless some bugs

So what's the point to give a name to a function expression? The answer is: to have access from that function from the function's body itself, without pollute the scope. Imaging for instance you want to add an event listener to a DOM node, but execute the listener only once:

document.body.addEventListener("click", function onclick() {
    // do something
    document.body.removeEventListener("click", onclick, false);
}, false);

So you don't pollute the scope with a lot of functions that you use only for purpose like that ones, and you can still have access to the function from the function's body. That's especially useful in ES5 where arguments.callee is deprecated, and for recursion.

Another difference between function expression is that you can invoke them immediately, but you can't do that for function declaration. So, for instance:

function() {
    console.log('foo');
}();

Will throw an exception, because the engine can't understand if it's a function declaration or a function expression. But if you force the engine to look at it as an expression:

!function() {
    console.log('foo');
}();

// or
(function(){
    console.log('foo');
}());

// etc, there are a lot of ways

Here we are: JS understand is an expression, therefore threats the function as an operator and not as a statement. And you obtain the IIFE (Immediately-Invoked Function Expression), that are useful in a lot of scenarios, specially where you want to isolate code.

So, back to you question, why the name of this function:

var aFunc = function(){};

is not aFunc?

Because, it's an expression. So the value knows nothing about the assignment on the left. It's like having:

var aFunc = -3;

Where the - is the Unary Negation operation and the 3 is the value: they knows nothing about aFunc, right? It's exactly the same with function expression, where function is the operator, and (){} is the value.

Answer 2

The term "anonymous function" is jargon, so likely what it means will change over time. There is no specification that states what it is, so it can be whatever you want it to be. And whatever you decide will likely be disputed by someone else. Jargon is like that (look up the word "trunking", a common jargon term in telephony).

Strictly, there are function declarations where the name is mandatory, e.g.

function foo() {
    ...
}

and function expressions where the name is optional. If the name is missing, e.g.:

var x = function () {
             ...
        };

then that, to me, is an anonymous function. If it has a name, e.g.

var x = function foo() {
             ...
        };

then it's a named function expression (and not an anonymous function). From my perspective, any function expression without an optional name is an anonymous function. There are many uses for function expressions, e.g.

// assignment to a variable
var x = function() {...}

// pass as a parameter
foo(function(){...})

// immediately executed and pass the result
foo( (function(){...}()) )

and so on. So in the OP, the right hand side of the assignment is a function expression with no name so to me, that's an anonymous function. The fact that it's then assigned to an identifier doesn't suddenly make it a named function expression.

Others may differ of course.

Incidentally, the results of:

function foo(){}

and

var foo = function(){};

are practically indistinguishable, the main difference is when the functions are created.

Answer 3

No, the function will not "take the name of the variable". The variable will hold a reference to an anonymous function. The function itself is still anonymous.

Note that this makes little difference in the end though, this function reference can be treated exactly the same as any regular named function once it's assigned. In fact, it makes so little difference, a named function can be treated like a variable holding a function reference too:

function foo() { }
foo();
foo = 'bar';
alert(foo); // bar

Answer 4

No it is not. The right hand side of your first statement is a Function Expression. It is anonymous as long as you don't assign it to a variable.

After you have assigned it, you can use it as a declared function.

See more details about function declarations in this question

Answer 5

No.

In the first example you are creating an anonymous function and then assigning it to "aFunc"

In the second example you declare a function and call it bFunc.

The most notable difference between the two is that you can't call "aFunc" until after the line where you assign it.