How is Object.prototype.toString.apply(value) different from value.toString()?

Question

From what I understand, the former will:

1. Find the toString method on Object
2. call it on value but with this bound to value

And value.toString() will.

1. Find the toString method somewhere in value's prototype chain
2. Call toString on value bound with this as value via the function invocation pattern

So the difference is if there is an overridden toString method in value... it will use that.

My question is:

1. Is that the only difference?
2. Conversely, is this pattern the standard pattern to use if we want to be guaranteed we're calling Parent's method and not potentially some overridden by Child? (In this case Parent = Object, Child = the class value comes from, if we're thinking classically, and method = toString.)

Answer 1

Object.prototype.toString.apple(value) will let you call on null, while you use null.toString(), it will produce an error.

Object.prototype.toString.apply(null);
>"[object Null]"

null.toString();
>TypeError: Cannot call method 'toString' of null

Answer 2

Object.prototype.toString can be a different method than value.toString() depending upon what the latter is.

> Object.prototype.toString.apply("asdfasdf")
"[object String]"
> "asdfasdf".toString()
"asdfasdf"
> Object.prototype.toString.apply(new Date)
"[object Date]"
> (new Date).toString()
"Tue Mar 05 2013 20:45:57 GMT-0500 (Eastern Standard Time)"

.prototype[function].apply (or .call or .bind) allow you to change the context of a method even though the context may not have such a method at all.

var o = {};
o.prototype = {x: function () { console.log('x'); }}
var y = {}
o.prototype.x.call(y)
y.x(); //error!

...so that is to say that

1. It's not the only difference
2. This doesn't necessarily have to do with a relationship between parent and child .. it just allows you to call one object's method (or any function) with a different object context.