Soluzioni alternative di ereditarietà di dattiloscritto?

Question

Sto provando a scoprire un modello per combinare più interfacce in una classe astratta. Attualmente posso combinare più interfacce tramite "implements" ma un'interfaccia non può dichiarare un costruttore. Quando devo presentare un costruttore, sono costretto a usare una classe astratta. Quando uso una classe astratta devo ri-dichiarare l'intera interfaccia composita! Sicuramente mi manca qualcosa?

interface ILayerInfo { 
    a: string; 
} 

interface ILayerStatic { 
    b(): string; 
} 

class Layer implements ILayerInfo, ILayerStatic { 
    constructor(info: ILayerInfo); 
    a: string; 
    b(): string; 
} 

RISPOSTA: uso 'nuovo':

interface Layer extends ILayerInfo, ILayerStatic { 
    new(info: ILayerInfo); 
} 

// usage: new Layer({ a: "" }); 

Answer 1

Dichiarare un costruttore sulla stessa interfaccia come i membri di istanza in realtà non ha molto senso - se avete intenzione di passare in un digita dinamicamente da utilizzare in un costruttore, è il lato statico della classe che verrebbe limitato. Quello che si vorrebbe fare è probabilmente qualcosa di simile:

interface Colorable { 
    colorize(c: string): void; 
} 

interface Countable { 
    count: number; 
} 

interface ColorCountable extends Colorable, Countable { 
} 

interface ColorCountableCreator { 
    new(info: {color: string; count: number}): ColorCountable; 
} 

class ColorCounted implements ColorCountable { 
    count: number; 
    colorize(s: string) { } 
    constructor(info: {color: string; count: number}) { 
     // ... 
    } 
} 

function makeThings(c: ColorCountableCreator) { 
    var results: ColorCountable[]; 
    for(var i = 0; i < 10; i++) { 
     results.push(new c({color: 'blue', count: i})); 
    } 
    return results; 
} 

var items = makeThings(ColorCounted); 
console.log(items[0].count); 

Vedi anche How does typescript interfaces with construct signatures work?