ECMAScript 6 ha una convenzione per le classi astratte?

Question

Sono stato sorpreso di non riuscire a trovare nulla sulle classi astratte durante la lettura su ES6. (Con "classe astratta" sto parlando del suo significato in Java, in cui una classe astratta dichiara le firme del metodo che una sottoclasse deve implementare per essere istantaneabile).

Qualcuno sa di alcune convenzioni che hanno preso piede per implementare classi astratte in ES6? Sarebbe bello essere in grado di cogliere una violazione astratta della classe con l'analisi statica.

Se dovessi generare un errore in fase di esecuzione per segnalare un tentativo di creazione di classi astratte, quale sarebbe l'errore?

Answer 1

ES2015 non dispone di classi in stile Java con costi integrati per il modello di progettazione desiderato. Tuttavia, ha alcune opzioni che possono essere utili, a seconda esattamente di ciò che stai cercando di realizzare.

Se volete una classe che non può essere costruita, ma la cui sottoclassi può, quindi è possibile utilizzare 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 

Per ulteriori dettagli su new.target, si consiglia di leggere questo quadro generale di come le classi nel lavoro ES2015: http://www.2ality.com/2015/02/es6-classes-final.html

Se stai specificamente alla ricerca di alcuni metodi che richiedono essere attuate, è possibile verificare che nella costruzione della superclasse così:

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