¿Cómo funcionan las interfaces de typescript con las firmas de construcción?

En mi búsqueda de la misma pregunta fui a ver cómo el Equipo de TypeScript hizo eso...

Están declarando una interfaz y luego una variable con un nombre que coincide exactamente con el nombre de la interfaz. Esta es también la forma de escribir funciones estáticas.

Ejemplo de lib.d.ts:

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

Lo intenté y funciona como encanto.

Desde la perspectiva del diseño, no es habitual especificar los requisitos del constructor en una interfaz. La interfaz debe describir las operaciones que puede realizar en un objeto. Se debe permitir que las diferentes clases que implementan la interfaz requieran diferentes parámetros de constructor si es necesario.

Por ejemplo, si tuviera una interfaz:

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

Podría tener implementaciones para almacenar los datos como una cookie, que no necesita parámetros de constructor, y una versión que almacena los datos en una base de datos, que necesita una cadena de conexión como parámetro constructor.

Si todavía desea definir constructores en una interfaz, hay una forma sucia de hacer esto, que usé para responder esta pregunta:

Interfaces con firmas de construcción sin comprobación de tipos

Bueno, una interfaz con una firma de construcción no está destinada a ser implementada por ninguna clase(a primera vista esto podría parecer extraño para los chicos con fondo de C#/Java como yo, pero darle una oportunidad). Es ligeramente diferente.

Por un momento piense en ello como una interfaz con una firma de llamada(como una @FunctionalInterface en el mundo Java). Su propósito es describir un tipo de función..algo así. Se supone que la firma descrita está satisfecha por un objeto de función...pero no cualquier nivel alto función o método. Debería ser una función que sabe cómo construir un objeto, una función que se llama cuando se usa la palabra clave new.

Así que una interfaz con una firma de construcción define la firma de un constructor ! El constructor de su clase que debe cumplir con la firma definida en la interfaz(piense en ello como el constructor implementa la interfaz). ¡Es como un constructor o una fábrica !

Aquí hay un breve fragmento de código que intenta demostrar la uso más común:

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

Para lograr el comportamiento deseado se podría usar Decoradores, aunque probablemente no sea para lo que se supone que se deben usar.

Esto

interface MyInterface {
    new ();
}

function MyInterfaceDecorator(constructor: MyInterface) {
}


@MyInterfaceDecorator
class TestClass {
    constructor () { }
}

Compila sin problemas. Por el contrario, la siguiente definición para TestClass

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

No compilará.