Jak działają interfejsy typescript z podpisami construct?

W poszukiwaniu dokładnie tego samego pytania poszedłem sprawdzić, jak zespół maszynopisu to zrobił...

Deklarują interfejs, a następnie zmienną o nazwie dokładnie odpowiadającej nazwie interfejsu. Jest to również sposób na typowanie funkcji statycznych.

Przykład z lib.d.ts:

interface Object {
    toString(): string;
    toLocaleString(): string;
    // ... rest ...
}
declare var Object: {
    new (value?: any): Object;
    (): any;
    (value: any): any;
    // ... rest ...
}

Z punktu widzenia projektowania, nie jest zwykle określanie wymagań konstruktora w interfejsie. Interfejs powinien opisywać operacje, które można wykonać na obiekcie. Różne klasy implementujące interfejs powinny mieć możliwość, aby wymagać różnych parametrów konstruktora, jeśli zajdzie taka potrzeba.

Na przykład, gdybym miał Interfejs:

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

Mogę mieć implementacje do przechowywania danych w formie pliku cookie, który nie wymaga żadnych parametrów konstruktora, a wersja, która przechowuje dane w bazie danych, która wymaga łańcucha połączeń jako parametru konstruktora.

Jeśli nadal chcesz definiować konstruktory w interfejsie, jest na to brudny sposób, który użyłem, aby odpowiedzieć na to pytanie:

Interfejsy z podpisami konstruktu Nie sprawdzanie typu

Cóż interfejs z podpisem konstruktu nie jest przeznaczony do implementacji przez żadną klasę(na pierwszy rzut oka może to wyglądać dziwnie dla facetów z tłem C#/Java, takich jak ja, ale daj mu szansę). Jest nieco inaczej.

Przez chwilę pomyśl o tym jako o interfejsie z sygnaturką wywołania (jak @FunctionalInterface w Java world). Jego celem jest opisanie typu funkcji..tak jakby. Opisywana sygnatura ma być spełniona przez obiekt funkcji...ale nie byle jaki wysoki poziom funkcja lub metoda. Powinna to być funkcja, która wie, jak skonstruować obiekt, funkcję, która zostanie wywołana, gdy używane jest słowo kluczowe new.

Więc interfejs z podpisem konstruktora definiuje podpis konstruktora ! Konstruktor twojej klasy, który powinien być zgodny z podpisem zdefiniowanym w interfejsie(pomyśl o tym, jak konstruktor implementuje interfejs). To jest jak budowniczy lub fabryka !

Oto krótki fragment kodu, który próbuje zademonstrować najczęściej używane:

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

Aby osiągnąć zamierzone zachowanie, możesz użyć dekoratorów , mimo że prawdopodobnie nie do tego powinny być używane.

To

interface MyInterface {
    new ();
}

function MyInterfaceDecorator(constructor: MyInterface) {
}


@MyInterfaceDecorator
class TestClass {
    constructor () { }
}

Kompiluje bez problemu. Natomiast poniższa definicja dla TestClass

// error TS2345: Argument of type 'typeof TestClass' is not assignable to parameter of type 'MyInterface'.
@MyInterfaceDecorator
class TestClass {
    constructor (arg: string) { }
}

Nie będzie kompilowany.