I have a self invoking function like this:
var f = (function f(){ return "123"; },
function g(){ return 2; },
function h(){ return "test"; })();
typeof f;
typeof f is always the type of what is returned in the last function definition. Like if h is last, then it is "string", but if I remove h and have g as last, then "number".
Could someone explain why?
Because the functions are separated by the , comma operator.
This evaluates the separated expressions, and returns the result of the last expression.
var x = ("a", "b", "c");
console.log(x); // "c"
So in your case, the last function is returned, as the result of the enclosing () group, and that's the one invoked by the trailing () function call.
// result from group---v v---invoked
var f = (func1, func2, func3)()
Let's break this down.
The comma operator in Javascript evaluates several expressions, and returns the last one:
>>> "a", 1
1
>>> 1, "a"
"a"
So when you take three anonymous functions and string them together with commas, it evaluates to the last one:
>>> (function f(){ return "123"; }, function g(){ return 2; }, function h(){ return "test"; })
function h(){ return "test"; }
Evaluating that result executes the function, returning "test".
Whichever function is last in the comma-separated list will be executed, and decide the overall return value.
var a, b, c;
The comma operator returns the last item. What you are doing is like:
var f = function(){}, function(){}, "string";
Which will make f a string, because only the last function is being called.
