Function.apply与Function.prototype.apply

Question

I recently looked into the code of firebugs console.log by calling console.log.toString() and got this:

function () { return Function.apply.call(x.log, x, arguments); }

As long as I understand this causes Function.apply to be called with its this referring to x.log and the arguments being x and arguments . Since Function.apply itself calls functions this will result in x.log to be called with its this referring to x and arguments as its arguments.

Which leads me to my question: Is there any reason to call Function.apply this way instead of just using Function.prototype.apply ? Or in other words, is there any difference between the above and return x.log.apply(x, arguments) ?

Edit: Since it's open source I took a quick look at the firebug sourcecode and found the place where this is created ( consoleInjector.js , line 73):

// Construct a script string that defines a function. This function returns
// an object that wraps every 'console' method. This function will be evaluated
// in a window content sandbox and return a wrapper for the 'console' object.
// Note that this wrapper appends an additional frame that shouldn't be displayed
// to the user.
var expr = "(function(x) { return {\n";
for (var p in console)
{
    var func = console[p];
    if (typeof(func) == "function")
    {
        expr += p + ": function() { return Function.apply.call(x." + p +
            ", x, arguments); },\n";
    }
}
expr += "};})";

// Evaluate the function in the window sandbox/scope and execute. The return value
// is a wrapper for the 'console' object.
var sandbox = Cu.Sandbox(win);
var getConsoleWrapper = Cu.evalInSandbox(expr, sandbox);
win.wrappedJSObject.console = getConsoleWrapper(console);

I'm almost sure now that this has something to do with Function to be in a different scope, which is what I sayed in my first comment to pst 's answer, but I still don't fully understand it. I may do a bit further research about that.

Answer 1

Consider this:

Function.hasOwnProperty("apply")             // false
Function.apply == Function.prototype.apply   // true
Function.__proto__ == Function.prototype     // true in FF which exposes proto

So Function.apply works because Function's [[prototype]] is Function.prototype . In this case both ought to work as desired.

However, consider that normal [GetProperty] rules still apply:

var f = function () {};
f.apply = "nubbits";
f.apply(/* err */);

Granted, I'd consider it "questionable code" to change the behavior of apply (and especially in an incompatible manner), but it's possible that the two forms differ .. Personally, I do not accommodate such hypothetical situations and I use f.apply in my code.