paso - parametros por referencia typescript

¿Cómo hacer que una clase implemente una firma de llamada en Typescript?

Question

He definido la siguiente interfaz en mecanografiado:

interface MyInterface {
    () : string;
}

Esta interfaz simplemente introduce una firma de llamada que no toma parámetros y devuelve una cadena. ¿Cómo implemento este tipo en una clase? He probado lo siguiente:

class MyType implements MyInterface {
    function () : string {
        return "Hello World.";
    }
}

El compilador me sigue diciendo que

La clase ''MyType'' declara la interfaz ''MyInterface'' pero no la implementa: el tipo ''MyInterface'' requiere una firma de llamada, pero Type ''MyType'' carece de una

¿Cómo puedo implementar la firma de llamada?

Answer 1

En caso de que si la interfaz invocable debe tener otros métodos, puede hacerlo así:

interface Greeter {
    (): void;
    setName(name: string): void;
}

class ConsoleGreeter {

    private constructor( // constructable via `create()`
        private name = ''world''
    ) {}

    public call(): void {
        console.log(`Hello ${this.name}!`);
    }

    public setName(name: string) {
        this.name = name;
    }

    public static create(): Greeter {
        const instance = new ConsoleGreeter();
        return Object.assign(
            () => instance.call(),
            {
                setName: (name: string) => instance.setName(name)
                // ... forward other methods
            }
        );
    }
}

const greeter = ConsoleGreeter.create();
greeter.setName(''Dolly'');
greeter(); // prints ''Hello Dolly!''

greeter instanceof ConsoleGreeter : la greeter instanceof ConsoleGreeter es false

Answer 2

Las clases no pueden coincidir con esa interfaz. Lo más cercano que se puede obtener, creo que es esta clase, que generará un código que funcionalmente coincida con la interfaz (pero no de acuerdo con el compilador).

class MyType implements MyInterface {
  constructor {
    return "Hello";
  }
}
alert(MyType());

Esto generará código de trabajo, pero el compilador se quejará de que MyType no se puede MyType porque tiene la firma new() = ''string'' (aunque si lo llama con new , devolverá un objeto).

Para crear algo que coincida exactamente con la interfaz sin que el compilador se queje, tendrás que hacer algo como esto:

var MyType = (() : MyInterface => {
  return function() { 
    return "Hello"; 
  }
})();
alert(MyType());

Answer 3

Los ejemplos de código en esta respuesta asumen la siguiente declaración:

var implementation: MyInterface;

Proporcionar una implementación de una interfaz invocable

Como seguimiento de la respuesta aceptada , como lo sugieren algunos de sus comentaristas, una función que coincida con la signatura de llamada de la interfaz implementa implícitamente la interfaz. De modo que puede usar cualquier función coincidente como implementación.

Por ejemplo:

implementation = () => "Hello";

No necesita especificar explícitamente que la función implemente la interfaz. Sin embargo, si quieres ser explícito, puedes usar un elenco:

implementation = <MyInterface>() => "Hello";

Proporcionando una implementación reutilizable

Si desea producir una implementación reutilizable de la interfaz como lo haría normalmente con una interfaz Java o C #, simplemente almacene la función en un lugar accesible para sus consumidores.

Por ejemplo:

function Greet() {
    return "Hello";
}

implementation = Greet;

Proporcionar una implementación parametrizada

Es posible que desee poder parametrizar la implementación de la misma manera que puede parametrizar una clase. Aquí hay una manera de hacer esto:

function MakeGreeter(greeting: string) {
    return () => greeting;
}

implementation = MakeGreeter("Hello");

Si desea que el resultado se escriba como la interfaz, simplemente establezca explícitamente el tipo de devolución o el valor arrojado.