Mehrfache Vererbung von Typoskripten?

Question

Ich versuche, ein Muster für die Kombination mehrerer Schnittstellen in einer abstrakten Klasse zu entdecken. Momentan kann ich mehrere Schnittstellen über "implements" kombinieren, aber eine Schnittstelle kann keinen Konstruktor deklarieren. Wenn ich einen Konstruktor einführen muss, muss ich eine abstrakte Klasse verwenden. Wenn ich eine abstrakte Klasse verwende, muss ich die gesamte zusammengesetzte Schnittstelle neu deklarieren! Sicherlich vermisse ich etwas?

interface ILayerInfo { 
    a: string; 
} 

interface ILayerStatic { 
    b(): string; 
} 

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

ANTWORT: Verwendung ‚neuer‘:

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

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

Answer 1

einen Konstruktor auf die gleiche Schnittstelle wie die Instanzmitglieder Deklarieren wirklich nicht viel Sinn machen - wenn Sie in einem passieren gehst Wenn Sie dynamisch in einem Konstruktor verwenden, ist die statische Seite der Klasse eingeschränkt. Was würden Sie tun möchten, ist wahrscheinlich so etwas wie folgt aus:

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); 

Siehe auch How does typescript interfaces with construct signatures work?