costructors d'emprunt et de la chaîne prototype

Question

dans de nombreux livres et tutoriel en ligne il y a des exemples sur le passage des données à un constructeur super-classe via un modèle de méthode d'emprunt:

var Parent = function(name) 
{ 
    this.name = name; 
    this.my_parent = "parent_property"; 
    this.go = function() 
    { 
     alert("GO") 
    } 

} 

var Child = function(name) 
{ 
    this.name = name; 
    this.my_child = "child_property"; 

    Parent.call(this); 

    alert(this.hasOwnProperty("go")) // HERE TRUE!!! 
} 

var ChildChild = function(name) 
{ 
    this.name = name; 
    this.su = function(){} 
} 

// PSEUDO CLASSICAL ECMA STANDARD 
Child.prototype = new Parent("PARENT"); 
ChildChild.prototype = new Child("CHILD"); 
var c = new ChildChild("CHILDCHILD"); 

maintenant ma question est la suivante: cela est exact? dans ce modèle les propriétés de la super classe sont copiées dans THIS mais dans un système OOP je pense que ces propriétés doivent être dans sa super classe . Maintenant constructeur BORROWING est seulement un autre modèle pour faire une sorte d'héritage, donc je ne pouvais pas utiliser le prototype et donc toutes les propriétés de la superclasse sont dans la dernière classe enfant ... mais je ne pense pas que ce soit efficace. Donc, à la fin, comment puis-je transmettre des données à une super-classe sans ce modèle?

Merci

Answer 1

En appelant .call() vous ne héritez pas dans le sens classique du mot au lieu vous dire des enfants à appliquer prototype parents sur lui-même et donc Child.prototype avait cloné propriétés et méthodes de Parent. Cela n'a aucun problème de performance, même si abandonner le prototype pour des raisons d'efficacité n'est pas une raison valable. Si je peux être honnête, je pense que l'application de paradigmes OO sur javascript est la plus grande erreur qu'un développeur javascript peut faire. Tout comme avoir à apprendre à faire face à l'immuabilité dans la programmation fonctionnelle en essayant de faire se comporter comme javascript classique OO ne fonctionnera que contre vous à long terme.

Il ne répond pas à votre question, mais il y a des tonnes de différentes façons d'appliquer a super functionality to javascript, mais je ne peux pas recommander car il n'y a pas de version définitive qui ne vient pas avec un inconvénient quelque part.

Answer 2

JavaScript n'a pas de support inhérent pour la construction de hiérarchies d'héritage. La façon JavaScript de faire des extensions de type serait d'ajouter des propriétés de la « classe mère » à la « classe enfant », à savoir

function Parent(foo) { 
    this.foo = foo; 
} 

Parent.prototype.sharedFoo = 'sharedFoo'; 

function Child(foo, bar) { 
    // call the parent constructor 
    Parent.call(this, foo); 
    this.bar = bar; 
} 

Child.prototype.sharedBar = 'sharedBar'; 

// copy the properties of the parent class 
for(var prop in Parent.prototype) { 
    if(Parent.prototype.hasOwnProperty(prop)) 
     Child.prototype[prop] = Parent.prototype[prop]; 
} 

Il est facilement possible d'ajouter véritable héritage prototypique, par exemple like this.

Via l'utilisation de la fonction clone(), il est maintenant possible de laisser l'objet prototype de la «classe enfant hérite de l'objet prototype de la « classe de base »:

function Parent(foo) { 
    this.foo = foo; 
} 

Parent.prototype.sharedFoo = 'sharedFoo'; 

function Child(foo, bar) { 
    // call the parent constructor 
    Parent.call(this, foo); 
    this.bar = bar; 
} 

// inherit from the parent class 
Child.prototype = clone(Parent.prototype); 

Child.prototype.sharedBar = 'sharedBar'; 

Answer 3

JavaScript est un basé sur un prototype , langage fonctionnel qui prétend être le cousin de Java.

Voici quelques éléments clés sur JavasSript:

• Tout est un objet, y compris les fonctions
• objet est plus comme Hash, il est une collection de paires de valeurs clés
• prototype lui-même est l'objet ainsi

Pour répondre à votre première question sur les performances du prototype "d'emprunt":

Généralement, une classe JavaScript contient une collection de [nom, objet fonction] paires. Lorsque vous empruntez le prototype de la classe parente , vous copiez en principe les valeurs de l'objet prototype parent dans l'objet prototype de la classe enfant.

La copie est par référence, lorsque la fonction est copiée, le code de fonction n'est pas dupliqué, seule la référence est copiée. Ceci est similaire aux pointeurs de fonction en langage C.

Ainsi, la seule perte de performance est la duplication de l'objet prototype, qui prend très peu de mémoire.

Pour répondre à votre deuxième question de savoir comment transmettre des données à la classe parent de manière propre.

Il y a beaucoup de bibliothèques là-bas qui a un certain héritage de style POO déjà intégré Vous pouvez rouler votre propre aussi, mais ce ne serait pas trivial.

Je recommande un cadre appelé Joose.

• Il prend en charge les classes, l'héritage, les mixins, les traits, les modificateurs de méthode et plus encore.
• Stable et utilisé dans les environnements de production.
• élégant et vous permettra d'économiser beaucoup de coups clés

Utilisation Joose, les constructeurs de parents peuvent être outrepassées ou augmentée, et SUPER() ou INNER() méthodes seront fournis pour accéder au constructeur d'origine, ou le constructeur de la sous-classe .