__proto__ VS. prototype en JavaScript

Question

Cette figure montre à nouveau que chaque objet a un prototype. Constructeur La fonction Foo a également son propre __proto__ qui est Function.prototype, et qui à son tour fait également référence via son __proto__ à la propriété l'objet.prototype. Ainsi, répétons-le, Foo.prototype est juste une propriété explicite de Foo qui fait référence au prototype des objets b et c. propriété de Foo qui fait référence au prototype des objets b et c.

var b = new Foo(20);
var c = new Foo(30);

Quelles sont les différences entre __proto__ y prototype ?

Ce chiffre est tiré de dmitrysoshnikov.com .

Answer 1

__proto__ est l'objet réel qui est utilisé dans la chaîne de recherche pour résoudre les méthodes, etc. prototype est l'objet qui est utilisé pour construire __proto__ lorsque vous créez un objet avec new :

( new Foo ).__proto__ === Foo.prototype;
( new Foo ).prototype === undefined;

Answer 2

prototype est une propriété d'un objet Function. C'est le prototype des objets construits par cette fonction.

__proto__ est une propriété interne d'un objet, pointant vers son prototype. Les normes actuelles fournissent un équivalent Object.getPrototypeOf(obj) méthode, bien que la norme de facto __proto__ est plus rapide.

Vous pouvez trouver instanceof en comparant les relations d'une fonction prototype d'un objet __proto__ et vous pouvez rompre ces relations en changeant prototype .

function Point(x, y) {
    this.x = x;
    this.y = y;
}

var myPoint = new Point();

// the following are all true
myPoint.__proto__ == Point.prototype
myPoint.__proto__.__proto__ == Object.prototype
myPoint instanceof Point;
myPoint instanceof Object;

Ici Point est une fonction constructeur, elle construit un objet (structure de données) de manière procédurale. myPoint est un objet construit par Point() donc Point.prototype est enregistré dans myPoint.__proto__ à ce moment-là.

Answer 3

prototype est créée lorsqu'une fonction est déclarée.

Par exemple :

 function Person(dob){
    this.dob = dob
 }; 

Person.prototype est créée en interne une fois que vous avez déclaré la fonction ci-dessus. De nombreuses propriétés peuvent être ajoutées à la fonction Person.prototype qui sont partagées par Person créées à l'aide de new Person() .

// adds a new method age to the Person.prototype Object.
Person.prototype.age = function(){return date-dob}; 

Il convient de noter que Person.prototype est un Object par défaut (il peut être modifié si nécessaire).

Chaque instance créée à l'aide de new Person() a un __proto__ qui pointe vers la propriété Person.prototype . C'est la chaîne que l'on traverse pour trouver une propriété d'un objet particulier.

var person1 = new Person(somedate);
var person2 = new Person(somedate);

crée 2 instances de Person ces 2 objets peuvent appeler age méthode de Person.prototype como person1.age , person2.age .

Dans l'image ci-dessus de votre question, vous pouvez voir que Foo est un Function Object et donc il a un __proto__ lien vers le Function.prototype qui est à son tour une instance de Object et dispose d'un __proto__ lien vers Object.prototype . Le lien proto se termine ici avec __proto__ dans le Object.prototype pointant vers null .

Tout objet peut avoir accès à toutes les propriétés de sa chaîne de proto liées par __proto__ et constitue ainsi la base de l'héritage prototypique.

__proto__ n'est pas un moyen standard d'accéder à la chaîne de prototypes, l'approche standard mais similaire consiste à utiliser la fonction Object.getPrototypeOf(obj) .

Le code ci-dessous pour instanceof opérateur permet de mieux comprendre :

objet instanceof L'opérateur de classe retourne true lorsqu'un objet est une instance d'une Classe, plus précisément si Class.prototype se trouve dans la chaîne proto de cet objet, alors l'objet est une instance de cette classe.

function instanceOf(Func){
  var obj = this;
  while(obj !== null){
    if(Object.getPrototypeOf(obj) === Func.prototype)
      return true;
    obj = Object.getPrototypeOf(obj);
  }
  return false;
}      

La méthode ci-dessus peut être appelée comme : instanceOf.call(object, Class) qui renvoie vrai si l'objet est une instance de Class.

Answer 4

Une bonne façon d'y penser est...

prototype est utilisé par constructor fonctions. Il aurait vraiment dû s'appeler quelque chose comme , "prototypeToInstall" puisque c'est ce que c'est.

y __proto__ est ce "prototype installé" sur un objet (qui a été créé/installé sur l'objet à partir de la dite constructor() fonction)

Answer 5

Je comprends : __proto__ et prototype servent tous à la technique de la chaîne de prototypes. la différence est que les fonctions nommées avec un soulignement (comme __proto__) ne sont pas du tout destinées à être invoquées explicitement par les développeurs. en d'autres termes, elles sont juste destinées à certains mécanismes comme inherit etc. elles sont 'back-end'. mais les fonctions nommées sans soulignement sont conçues pour être invoquées explicitement, elles sont 'front-end'.