J'ai passé les dernières heures à essayer de trouver une solution à mon problème, mais cela semble désespéré.
Fondamentalement, j'ai besoin de savoir comment appeler une méthode parent à partir d'une classe enfant. Tout ce que j'ai essayé jusqu'à présent finit par ne pas fonctionner ou par écraser la méthode parente.
J'utilise le code suivant pour configurer la POO en javascript:
// SET UP OOP
// surrogate constructor (empty function)
function surrogateCtor() {}
function extend(base, sub) {
// copy the prototype from the base to setup inheritance
surrogateCtor.prototype = base.prototype;
sub.prototype = new surrogateCtor();
sub.prototype.constructor = sub;
}
// parent class
function ParentObject(name) {
this.name = name;
}
// parent's methods
ParentObject.prototype = {
myMethod: function(arg) {
this.name = arg;
}
}
// child
function ChildObject(name) {
// call the parent's constructor
ParentObject.call(this, name);
this.myMethod = function(arg) {
// HOW DO I CALL THE PARENT METHOD HERE?
// do stuff
}
}
// setup the prototype chain
extend(ParentObject, ChildObject);
Je dois d'abord appeler la méthode du parent, puis y ajouter des éléments supplémentaires dans la classe enfant.
Dans la plupart des langages POO, ce serait aussi simple que d'appeler parent.myMethod()
Mais je ne peux vraiment pas comprendre comment c'est fait en javascript.
Toute aide est très appréciée, merci!
la source
ParentClass.prototype.myMethod.apply() or
ParentClass.prototype.myMethod.call () `, comme vous le faites avec votre constructeur.ParentClass.prototype.myMethod.call(this, arg1, arg2, arg3...);
)myMethod
dans votre classe.Le style ES6 vous permet d'utiliser de nouvelles fonctionnalités, telles que le
super
mot-clé.super
mot-clé, tout est question de contexte de classe parent, lorsque vous utilisez la syntaxe des classes ES6. À titre d'exemple très simple, passez à la caisse:En outre, vous pouvez utiliser
super
pour appeler le constructeur parent:Et bien sûr, vous pouvez l'utiliser pour accéder aux propriétés de la classe parent
super.prop
. Alors, utilisez ES6 et soyez heureux.la source
super
l'appeler? Y a-t-il une équivalence dans «l'ancien» JS?super()
dans les méthodes statiques; on dirait que vous l'avez utilisé dans le constructeur.Eh bien, pour ce faire, vous n'êtes pas limité par l'
Class
abstraction d'ES6. L'accès aux méthodes prototypes du constructeur parent est possible via la__proto__
propriété (je suis presque sûr qu'il y aura d'autres codeurs JS pour se plaindre qu'il est déprécié) qui est dépréciée mais en même temps découvert qu'il s'agit en fait d'un outil essentiel pour les besoins de sous-classification ( en particulier pour les besoins de sous-classification Array). Ainsi, bien que la__proto__
propriété soit toujours disponible dans tous les principaux moteurs JS que je connais, ES6 a introduit laObject.getPrototypeOf()
fonctionnalité en plus. L'super()
outil dans leClass
abstraction en est un sucre syntaxique.Donc, dans le cas où vous n'avez pas accès au nom du constructeur parent et que vous ne voulez pas utiliser l'
Class
abstraction, vous pouvez toujours faire comme suit;la source
En cas de niveau d'héritage multiple, cette fonction peut être utilisée comme méthode super () dans d'autres langues. Voici un violon de démonstration , avec quelques tests, vous pouvez l'utiliser comme ceci, à l'intérieur de votre méthode:
call_base(this, 'method_name', arguments);
Il utilise des fonctions ES assez récentes, une compatibilité avec les anciens navigateurs n'est pas garantie. Testé dans IE11, FF29, CH35.
la source
Que diriez-vous de quelque chose basé sur l'idée de Douglas Crockford:
la source
Voici un bon moyen pour les objets enfants d'avoir accès aux propriétés et méthodes parentes à l'aide de la chaîne de prototypes de JavaScript, et il est compatible avec Internet Explorer. JavaScript recherche des méthodes dans la chaîne de prototypes et nous voulons que la chaîne de prototypes de l'enfant ressemble à ceci:
Instance enfant -> Prototype de l'enfant (avec méthodes Child) -> Prototype du parent (avec méthodes Parent) -> Prototype d'objet -> null
Les méthodes enfants peuvent également appeler des méthodes parent masquées, comme indiqué dans les trois astérisques *** ci-dessous.
Voici comment:
la source
Il existe une solution beaucoup plus simple et plus compacte pour la recherche de prototypes à plusieurs niveaux, mais elle nécessite une
Proxy
assistance. Utilisation:SUPER(<instance>).<method>(<args>)
par exemple, en supposant deux classesA
etB extends A
avec la méthodem
:SUPER(new B).m()
.la source
Bien que vous puissiez appeler la méthode parent par le prototype du parent, vous devrez transmettre l'instance enfant actuelle pour utiliser
call
,apply
oubind
méthode. Labind
méthode créera une nouvelle fonction, je ne le recommande donc pas si vous vous souciez des performances, sauf qu'elle n'est appelée qu'une seule fois.Vous pouvez également remplacer la méthode enfant et placer la méthode parent sur l'instance tout en appelant la méthode enfant d'origine.
la source