What is the difference between foo.toString() and Object.prototype.toString.call(foo)?

Question

If I define a function:

function foo() {
        alert(this.x);
}

I can print the function definition by calling the toString method on the foo function.

console.log(foo.toString())

output:

function foo() { alert(this.x); }

If I then run

console.log(Object.prototype.toString.call(foo))

output:

"[object Function]"

It is surprising the me that the output is different. I thought these two forms were equivalent?, i.e. the foo function inherited the toString method from the top level Object and using Object.prototype.toString.call(foo) was just calling toString passing the foo function as the this.
What is the difference between these two forms of invocation?

Answer 1

What is the difference between these two forms of invocation?

It's not just a difference in the form of the invocation, you're also calling a different function entirely.

i.e. the foo function inherited the toString method from the top level Object and using Object.prototype.toString.call(foo) was just calling toString passing the foo function as the this.

All perfect, except the first bit. :-) foo doesn't inherit toString from Object.prototype, because foo is a function, and Function.prototype (which inherits from Object.prototype) overrides toString to give it different behavior.

You can see that like this:

console.log(foo.toString === Object.prototype.toString); // false

It's also entirely possible for foo to have its own toString, overriding the one it inherits from Function.prototype, but by default it doesn't.

So changing just the form of the invocation, we'd get these, which are equivalent:

console.log(foo.toString());

and

console.log(foo.toString.call(foo));

or if we know foo doesn't override Function.prototype's version, then:

console.log(Function.prototype.toString.call(foo));