Pourquoi ne hasOwnProperty de ne pas reconnaître les fonctions sur un prototype de l'objet?
Je comprends que le hasOwnProperty
méthode en JavaScript permet d'identifier les propriétés du type de courant, mais il y a quelque chose dans la chaîne de prototype ici c'est confus pour moi.
Imaginons que je définir un type appelé Bob, et d'attribuer deux fonctions enfant à mon Bob type de deux façons différentes:
function Bob()
{
this.name="Bob";
this.sayGoodbye=function()
{
console.log("goodbye");
}
}
Bob.prototype.sayHello= function()
{
console.log("hello");
}
Maintenant en plus d'avoir accès à la fermeture de la portée dans le cas de sayGoodbye
, il me semble que les deux fonctions appartenant à la Bob
classe devrait être plus ou moins égale. Cependant, quand je regarde avec hasOwnProperty
ils ne sont pas les mêmes dans la mesure où le JavaScript est concerné:
var myBob = new Bob();
console.log( myBob.name ); //Bob, obviously
console.log( myBob.hasOwnProperty("sayHello")); //false
console.log( myBob.hasOwnProperty("sayGoodbye")); //true
console.log( "sayHello" in myBob ); //true
Ce qui se passe ici en termes de portée? Je ne pouvais pas créer une instance de la Bob
type sans avoir la sayHello()
et sayGoodbye()
propriétés sont connectés, alors pourquoi est le prototype de la méthode d'un citoyen de deuxième classe autant que hasOwnProperty
est concerné? Est Bob.prototype
un type qui existe en quelque sorte indépendamment de la Bob
type, à partir de laquelle Bob
hérite de tout?
hasOwnProperty
n'existe que pour vérifier l'objet lui-même pour les propriétés, il indique explicitement ne pas marcher jusqu'à la chaîne de prototype, car cela irait à l'encontre du but.Ce que je cherchais pour la clarification est pourquoi les propriétés d'un type de modèle ne seraient pas identifiés par
hasOwnProperty
.L'accès à la propriété n'a rien à voir avec l'étendue, il est tout à fait différent.
La vraie réponse est parce que
hasOwnProperty()
a été conçu. Il vérifie uniquement les propriétés directement sur l'objet, mais pas n'importe où dans la chaîne de prototype. Je peux voir une justification pour une fonction différente qui vous indique si la propriété est sur l'objet ou dans son propre prototype, mais ce n'est pas ce .hasOwnProperty()
a été écrit pour faire. Vous pourriez écrire une telle fonction.on est reconnaissant que la portée n'a rien à voir avec l'accès à la propriété. Le premier a trait à la résolution de variables dans un environnement lexical, l'autre concerne les nom de la propriété résolution sur un objet et son
[[Prototype]]
de la chaîne.
OriginalL'auteur glenatron | 2014-03-17
Vous devez vous connecter pour publier un commentaire.
Je pense que vous êtes confus quelques concepts ici. Prenons cette citation de la MDN:
Donc, c'est la clé ici. Lorsque vous utilisez
new
JavaScript attribuera une nouvelle marque de l'objet àthis
et retour, qu'est ce qu'une instance est. Toute propriété déclarée à l'intérieur du constructeur est un la propriété. Propriétés déclarées sur leprototype
ne le sont pas, puisqu'ils sont partagés avec d'autres instances du même objet.Et un
prototype
est aussi unObject
, par exemple:Bob.prototype
qui aurait accès à toutes les propriétés communes de laBob
type, mais pas de son constructeur? En supposant que j'ai été suffisamment ivre qu'il semblait être une bonne idée.Oui, comment vous faire de l'héritage,
NewObject.prototype = Object.create(Bob.prototype)
il existe déjà un objet. Vous n'avez pas à instancier un pour lire ce qui est en elle.
ce n'est pas comment I faire de l'héritage, mais il est très probablement que je doit ne héritage. Normalement je venais de dire
James.prototype = new Bob()
Eh bien, oui, c'est comment vous pouvez le faire dans les vieux navigateurs, mais c'est un peu hacky dans un sens... Vérifier le polyfill ici developer.mozilla.org/en-
OriginalL'auteur elclanrs
Qui n'est pas correct. hasOwnProperty identifie propre propriétés d'un objet, c'est que les propriétés de l'objet lui-même. Il ne tient pas compte des propriétés héritées sur un objet
[[Prototype]]
de la chaîne.par exemple
L'objet foo hérite également un toString méthode de l'Objet.prototype, mais ce n'est pas un "propre" de la propriété:
foo.prototype.name
spécifiquement, de sorte que la propriété n'existe que sur le type defoo
et c'est les enfants. Bien que la définition de propriétés explique où je suis allé mal, je ne pense pas qu'il serait illogique si toutes les propriétés uniques appartenant àfoo
et ses enfants étaient considérés comme des propriétés defoo
plutôt que seulement ceux dans la déclaration de la fonction.OriginalL'auteur RobG