Wie funktionieren Typoskript-Schnittstellen mit Konstruktsignaturen?

Konstruieren Signaturen-in-Schnittstellen sind nicht vorhanden in der Klassen; Sie sind nur für die Definition der vorhandenen JS-APIs definieren, dass eine "neue" -Funktion können. Hier ist ein Beispiel mit Schnittstellen new Signaturen, die funktioniert:

interface ComesFromString {
    name: string;
}

interface StringConstructable {
    new(n: string): ComesFromString;
}

class MadeFromString implements ComesFromString {
    constructor (public name: string) {
        console.log('ctor invoked');
    }
}

function makeObj(n: StringConstructable) {
    return new n('hello!');
}

console.log(makeObj(MadeFromString).name);

Dies schafft eine wirkliche Einschränkung für das, was Sie aufrufen können makeObj mit:

class Other implements ComesFromString {
    constructor (public name: string, count: number) {
    }
}

makeObj(Other); //Error! Other's constructor doesn't match StringConstructable

InformationsquelleAutor der Antwort Ryan Cavanaugh

Aus einer design-Perspektive, ist es nicht üblich, geben Sie den Konstruktor Anforderungen in einem interface. Die Schnittstelle sollte beschreiben die Operationen, die Sie durchführen können auf ein Objekt. Verschiedene Klassen, die das interface implementieren, erlaubt werden sollte, erfordern verschiedene Konstruktor-Parameter, wenn Sie brauchen.

Zum Beispiel, wenn ich eine Schnittstelle:

interface ISimplePersistence {
    load(id: number) : string;
    save(id: number, data: string): void;
}

Ich hätte Implementierungen für die Ablage der Daten als cookie, die braucht keine Konstruktor-Parameter, und eine version, die speichert die Daten in einer Datenbank, die eine Verbindungszeichenfolge als parameter des Konstruktors.

Wenn Sie immer noch wollen, um zu definieren, Konstruktoren in einer Schnittstelle, es ist ein schmutziger Weg, dies zu tun, die ich verwendet, um diese Frage zu beantworten:

Schnittstellen mit konstruieren Signaturen keine Typ-überprüfung

InformationsquelleAutor der Antwort user75525

Sowie eine Schnittstelle mit einem Konstrukt Signatur ist nicht dazu gedacht, realisiert zu werden von einer Klasse(auf den ersten Blick mag dies seltsam Aussehen für die Jungs mit C#/Java hintergrund gefällt mir, sondern ihm eine chance geben). Es ist etwas anders.

Für einen moment denken, es als eine Schnittstelle mit einem call-Unterschrift(wie ein @FunctionalInterface im Java-Welt). Sein Zweck ist es, zu beschreiben, eine Funktion geben..Art. Der beschriebene Signatur soll zufrieden sein, die durch ein function-Objekt...aber nicht irgendwelche high-level-Funktion oder einer Methode. Es sollte eine Funktion sein, die weiß, wie zu bauen ein Objekt, eine Funktion, die aufgerufen wird, wenn new - Schlüsselwort verwendet wird.

Also eine Schnittstelle, mit der ein Konstrukt Signatur definiert die Signatur eines Konstruktors ! Der Konstruktor der Klasse, die beachtet werden sollten, mit der Unterschrift in der Schnittstelle definiert(man denke daran, wie der Konstruktor die Schnittstelle implementiert). Es ist wie ein builder oder eine factory !

Hier ein kurzes code-snippet, das versucht zu zeigen, die häufigste Verwendung:

interface ClassicInterface { //old school interface like in C#/Java
    method1();
    ...
    methodN();
}

interface Builder { //knows how to construct an object
    //NOTE: pay attention to the return type
    new (myNumberParam: number, myStringParam: string): ClassicInterface
}

class MyImplementation implements ClassicInterface {
    //The constructor looks like the signature described in Builder
    constructor(num: number, s: string) { } //obviously returns an instance of ClassicInterface
    method1() {}
    ...
    methodN() {}
}

class MyOtherImplementation implements ClassicInterface {
    //The constructor looks like the signature described in Builder
    constructor(n: number, s: string) { } //obviously returns an instance of ClassicInterface
    method1() {}
    ...
    methodN() {}
}

//And here is the polymorphism of construction
function instantiateClassicInterface(ctor: Builder, myNumberParam: number, myStringParam: string): ClassicInterface {
    return new ctor(myNumberParam, myStringParam);
}

//And this is how we do it
let iWantTheFirstImpl = instantiateClassicInterface(MyImplementation, 3.14, "smile");
let iWantTheSecondImpl = instantiateClassicInterface(MyOtherImplementation, 42, "vafli");

InformationsquelleAutor der Antwort egelev