En quoi Object.prototype.toString.apply(value) est-il différent de value.toString() ?

Question

D'après ce que j'ai compris, les premiers le feront :

1. Trouvez le toString sur un objet
2. l'appeler value mais avec this lié à value

Et value.toString() volonté.

1. Trouvez le toString quelque part dans value La chaîne de prototypes de l'entreprise
2. Appelez toString sur la valeur liée avec this comme valeur via le modèle d'invocation de fonction

Donc la différence est que s'il y a une surcharge toString en valeur... il l'utilisera.

Ma question est la suivante :

1. C'est la seule différence ?
2. A l'inverse, ce modèle est-il le modèle standard à utiliser si l'on veut être sûr d'appeler Parent et non une méthode potentiellement surchargée par l'utilisateur. Child ? (Dans ce cas, Parent = Objet, Child = la classe d'où provient la valeur, si nous pensons classiquement, et method = toString).

Answer 1

Object.prototype.toString.apple(value) vous permettra de faire appel à null alors que vous utilisez null.toString() il produira une erreur.

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

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

Answer 2

Object.prototype.toString peut être une méthode différente de value.toString() en fonction de ce dernier.

> 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 (ou .call o .bind ) vous permettent de modifier le contexte d'une méthode, même si le contexte ne possède pas du tout une telle méthode.

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

...ce qui revient à dire que

1. Ce n'est pas la seule différence
2. Cela n'a pas nécessairement à voir avec une relation entre parent et enfant cela vous permet simplement d'appeler la méthode d'un objet (ou toute fonction) avec un contexte d'objet différent.

Answer 3

Oui, tu as raison. Je n'ai pas l'habitude de voir des gens appeler Object.prototype.toString directement de cette manière (il est généralement plus logique de laisser les objets remplacer leur toString ) mais il est certainement très courant et recommandé pour d'autres méthodes telles que Object.prototype.hasOwnProperty .