No concept of overloading in JavaScript

Question

Check this fiddle or the code below:

 function abc(s) {
     console.log('in abc(s)');
 }

 function abc(s, t) {
     console.log('in abc(s,t)');
 }

 abc('1');

The output of this question is always in abc(s,t)

Can someone please explain me whats going on here and why ?

Answer 1

In Javascript there is no overload concept.

You can however write a function that checks how many arguments have been passed by using the arguments value.

function foo(s, t) {
    if (arguments.length == 2) {
        ...
    } else {
        ...
    }
}

all arguments that the function expects in the signature but that are not passed by the caller are received as undefined. You can also write variadic functions by simply accessing the n-th argument passed with arguments[i]. Note however that arguments is not a Javascript array, so not all array methods are available for it.

About being able to redefine the same function multiple times without errors things are a bit complex to explain because the rules are strange.

A simple explanation is you could think of is that function is an executable statement like it is in Python and so the last function definition wins. This would be wrong however because, differently from Python, the following is legal Javascript code:

console.log(square(12));
function square(x) { return x*x; }

i.e. you can call a function in lines that are preceding the definition (in a script: of course typing those two lines in a Javascript console wouldn't work).

A slightly more correct explanation is that the compiler first parses all the function definitions (last wins) and then starts executing the code. This mental model works if you don't put functions inside if because what happens in practice in that case is implementation dependent (and I'm not talking about crazy IE, but even that FF and Chrome will do different things). Just don't do that.

You can even use the form

var square = function(x) { return x*x; }

and in this case it's a simple assignment of a "function expression" to a variable that is executed when the flow passed through it (so it's ok to place different implementations of a function inside different if branches, but you cannot call the function before assigning it an implementation).