Crockford Prototypical Inheritance ... pas de chaîne prototype? Pas super?

Question

Essayer d'en savoir un peu plus sur l'approche de Crockford de l'héritage prototypique par laquelle il élimine essentiellement le constructeur, éliminant ainsi toute possibilité réelle pour une chaîne prototype ou tirant parti de l'idée de «super». Est-ce intentionnel basé sur la théorie derrière prototypique?

La raison pour laquelle je suis tombé dessus est que je voulais créer une classe de base avec une méthode init qui faisait des choses jquery communes (ces méthodes sont conçues pour automatiser la création d'un plugin jquery à partir d'un objet). ? p = 51)

Par exemple, je ne veux pas répéter cela dans chacune de mes méthodes init this.options = $ .extend ({}, this.options, options); Donc, je voulais avoir cela dans un init de base, remplacer l'init dans mes objets étendus, puis appeler this.prototype.init dans le override pour prendre soin de ce truc répété.

La pièce objet.create ne semble pas me laisser faire ça. Est-ce que j'ai râté quelque chose?

Answer 1

La technique est centrée sur la chaîne du prototype, ce type d'héritage est également connu comme héritage différentiel.

Par exemple:

var obj = {}; 
var obj1 = Object.create(obj); 
var obj2 = Object.create(obj1); 

La chaîne prototype de obj2 ressemble à ceci:

 
      --------  --------   ------------------ 
obj2 ---> | obj1 | -----> | obj | -----> | Object.prototype | -----> null 
      --------  -------   ------------------ 

La flèche qui relie les objets dans l'exemple ci-dessus est la propriété [[Prototype]] interne, et qui forme la chaîne prototype.

Lorsque vous essayez d'accéder à une propriété, par exemple dans obj2, il sera recherché le long de tous les objets sur la chaîne de prototype jusqu'à ce que se trouve, sinon la propriété accesseur simplement céder undefined

Le concept de super n'existe pas vraiment, bien qu'il existe des moyens de connaître le [[Prototype]] d'un objet.

La 5ème édition ECMAScript a introduit la méthode Object.getPrototypeOf, par exemple:

Object.getPrototypeOf(obj2) === obj1; // true 

Cependant, cette méthode est not widely supported yet (avec le Object.create standard).

Certaines implémentations permettent d'accéder à un objet [[Prototype]] de la propriété par __proto__, .: par exemple

obj2.__proto__ === obj1; // true 

Mais rappelez-vous que __proto__ est non standard.

La méthode isPrototypeOf, une partie de ECMAScript 3, vous permet de savoir si un objet est dans la chaîne prototype d'une autre, par exemple:

obj1.isPrototypeOf(obj2);    // true 
obj.isPrototypeOf(obj2);    // true 
Object.prototype.isPrototypeOf(obj2); // true 

En conclusion, une propriété est résolue comme il est bientôt trouvé dans la chaîne de prototype, et si vous voulez éviter __proto__ et Object.getPrototypeOf (depuis le premier est non-standard et l'ancien n'est pas encore largement pris en charge) , je voudrais simplement vous recommande de préfixer votre méthode init dans l'objet de base, il peut donc être accessible à partir des cas plus spécifiques, par exemple:

var base = { 
    baseInit: function() { /*...*/ } 
}; 

var specific = Object.create(base); 
specific.init = function() { 
    //... 
    this.baseInit(); 
    //... 
}; 

specific.init();