Est-ce que ECMAScript 6 a une convention pour les classes abstraites? [dupliquer]
cette question a déjà une réponse ici:
j'ai été surpris de ne rien trouver sur les classes abstraites en lisant sur ES6. (Par "classe abstraite" je parle de l' Java Signification de celui-ci, dans lequel une classe abstraite déclare des signatures de méthode qu'une sous-classe doit implémenter pour être instanciable).
est-ce que quelqu'un connaît des conventions qui ont été adoptées pour mettre en place des classes abstraites dans ES6? Ce serait bien de pouvoir saisir une violation de classe abstraite avec analyse statique.
si je devais soulever une erreur à l'exécution pour signaler une tentative d'instanciation de classe abstraite, quelle serait l'erreur?
1 réponses
ES2015 N'a pas de cours de style Java avec les moyens intégrés pour votre modèle de conception désiré. Cependant, il a quelques options qui peuvent être utiles, selon exactement ce que vous essayez d'accomplir.
si vous voulez une classe qui ne peut pas être construite, mais dont les sous-classes peuvent, alors vous pouvez utiliser new.target :
class Abstract {
constructor() {
if (new.target === Abstract) {
throw new TypeError("Cannot construct Abstract instances directly");
}
}
}
class Derived extends Abstract {
constructor() {
super();
// more Derived-specific stuff here, maybe
}
}
const a = new Abstract(); // new.target is Abstract, so it throws
const b = new Derived(); // new.target is Derived, so no error
Pour plus de détails sur new.target , vous voudrez peut-être lire ce général aperçu du fonctionnement des cours en ES2015: http://www.2ality.com/2015/02/es6-classes-final.html
si vous cherchez spécifiquement à exiger que certaines méthodes soient mises en œuvre, vous pouvez vérifier que dans le constructeur superclass aussi bien:
class Abstract {
constructor() {
if (this.method === undefined) {
// or maybe test typeof this.method === "function"
throw new TypeError("Must override method");
}
}
}
class Derived1 extends Abstract {}
class Derived2 extends Abstract {
method() {}
}
const a = new Abstract(); // this.method is undefined; error
const b = new Derived1(); // this.method is undefined; error
const c = new Derived2(); // this.method is Derived2.prototype.method; no error