Prototype "Bind" method issue

Question

Function.prototype.bind = function(){
 var fn = this, args = Array.prototype.slice.call(arguments), object = args.shift();
 return function(){
 return fn.apply(object,
 **args.concat(Array.prototype.slice.call(arguments))**);
 };
};

This function is in Prototype. Does it equal to:

Function.prototype.bind = function(){
 var fn = this, args = Array.prototype.slice.call(arguments), object = args.shift();
 return function(){
 return fn.apply(object,**args**);
 };
};

In my opinion, args.concat(Array.prototype.slice.call(arguments)) == args, since the anonymous function haven't any arguments. What is the matter?

Answer 1

No, they aren't the same.

Tthe purpose of concatenating the arguments is to provide a way of partially apply (or curry) the function, pre-filling arguments when bind is used and being able to add more later when the function that bind returns is used, for example:

var obj = {
 fx: function() {
 alert(Array.prototype.join.call(arguments, ', '));
 }
};
var fx2 = obj.fx.bind(obj, 1, 2, 3);
fx2(4, 5); // Alerts "1, 2, 3, 4, 5"

As you can see in the last two lines of code, when I declare fx2, I'm passing obj as the first argument (this will ensure the context, used as the object variable on the bind implementation), then I pass the values 1,2 and 3.

Those values are stored in the args variable of the outer closure of bind, then as you see in the bind implementation, another function is returned.

That function returned in my example is fx2 after the assignment, in the last line you see I call that function, passing two additionally arguments.

Finally the returned function will call obj.fx with the two argument lists, the arguments we pre-filled when calling bind (1,2,3) and the arguments when the function actually executed (4,5).

That is why makes sense concatenating the two argument objects.

Answer 2

the anonymous function haven't any arguments

The anonymous function can actually have arguments (as can the bind method itself, which also doesn't declare any arguments).

Type-checking in JavaScript is non-existent: you can pass fewer arguments into a function than are declared in the function(...) signature (in which case the arguments that aren't passed get received as undefined), and you can pass more than declared, in which case the only way to read them is through the arguments array, which always contains exactly how many arguments were passed in, regardless of what's in the function signature.

It's generally considered polite to put a comment in the signature (function(x, /* y, ... */)) to indicate that more arguments will be read using the arguments array.