Cómo hacer una clase implemente una firma llamada a máquina de escribir?

Question

Cómo hacer una clase implemente una firma llamada a máquina de escribir?

votos

26

He definido la siguiente interfaz a máquina de escribir:

interface MyInterface {
    () : string;
}

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

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

El compilador me dice que

'MyType' clase declara interfaz 'MyInterface', pero no ponerlo en práctica: Tipo 'MyInterface' requiere una firma llamada, pero Type 'MyType' carece de uno

¿Cómo puedo aplicar la firma llamada?

typescript

Publicado el 07/10/2012 a las 15:22
fuente por usuario Valentin

En otros idiomas...

3 respuestas

votos

4

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

var implementation: MyInterface;

Proporcionar una implementación de un interfaz invocable

Como seguimiento a la respuesta aceptada , según lo sugerido por algunos de sus comentaristas, una función que coincide con la firma llamado de la interfaz implícita implementa la interfaz. Por lo tanto se puede utilizar cualquier función de emparejamiento como una aplicación.

Por ejemplo:

implementation = () => "Hello";

No es necesario especificar explícitamente que la función implementa la interfaz. Sin embargo, si usted quiere ser explícita, se puede utilizar un reparto:

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

Proporcionando una implementación reutilizable

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

Por ejemplo:

function Greet() {
    return "Hello";
}

implementation = Greet;

Proporcionando una implementación parametrizado

Es posible que desee para poder parametrizar la aplicación de la misma manera que es posible parametrizar una clase. He aquí una manera de hacer esto:

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

implementation = MakeGreeter("Hello");

Si desea que el resultado que se escribe como la interfaz, acaba de establecer explícitamente el tipo de retorno o fundido se devuelve el valor.

Respondida el 23/12/2013 a las 02:45
fuente por usuario Sam

votos

1

En caso de interfaz invocable debe tener otros métodos que se pueden hacer de esta manera:

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!'

Desventaja: greeter instanceof ConsoleGreeteresfalse

Respondida el 25/01/2018 a las 05:08
fuente por usuario teq

Peter Olson · Accepted Answer · 2012-10-07 16:32

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

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

Esto generará el código de trabajo, pero el compilador se quejará de que MyTypeno es exigible, ya que tiene la firma new() = 'string'(a pesar de que si se llama con new, devolverá un objeto).

Para crear algo que actally coincide con la interfaz sin la queja del compilador, que tendrá que hacer algo como esto:

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