Pourquoi est-ce que le fait de définir la propriété prototype d'une fonction de constructeur sur null
n'empêche pas les objets créés à partir de cette fonction d'appeler vers des méthodes sur Object.prototype
, de la même manière que la définition du prototype sur Object.create(null)
?
C'est pourquoi c'est le cas:
function Foo(){} Foo.prototype = null; console.log(new Foo().toString); //outputs function toString() { [native code] } (or whatever) function Foo(){} Foo.prototype = Object.create(null); console.log(new Foo().toString); //output undefined
Oui , votre observation est correcte: une fonction construite avec le new
opérateur aura toujours un prototype d'objet dans ce cas Object.prototype
et il est en effet différent d'une fonction créée avec Object.create.
On peut voir ce comportement complètement spécifié dans la spécification de langue ES5 sur laquelle JavaScript est basé. Voyons cela.
new
: En citant la spécification de la méthode [[Construct]]
des fonctions qui indique comment la création d'objet à l'aide du new
opérateur est effectuée, nous pouvons voir que ce qui suit est spécifié:
Si Type (proto) n'est pas Object, définissez la propriété interne [[Prototype]] d'obj à l'objet prototype Object Object standard tel que décrit en 15.2.4.
Object.create
: D'autre part, si nous vérifions The spec for Object.create
nous pouvons voir que Object.create(o)
spécifie:
Définissez la propriété interne [[Prototype]] d'obj à O.
Ce qui signifie que nous pouvons le définir, il vérifie aussi explicitement qu'il est nul ou Objet dans cet algorithme (s'il vous plaît , suivez le lien vers la spécification et lisez-le :))
Ainsi, le prototype des objets appelés avec le new Foo
est Object.prototype
et non null
. Il est impossible de créer des objets sans prototype sans Object.create
utilisant uniquement des méthodes standard.