objetos - llamar un objeto en typescript

Definición del tipo de devolución de llamada de TypeScript

Question

Tengo la siguiente clase en TypeScript:

class CallbackTest
{
    public myCallback;

    public doWork(): void
    {
        //doing some work...
        this.myCallback(); //calling callback
    }
}

Estoy usando la clase así:

var test = new CallbackTest();
test.myCallback = () => alert("done");
test.doWork();

El código funciona, por lo que muestra un cuadro de mensaje como se esperaba.

Mi pregunta es: ¿hay algún tipo que pueda proporcionar para mi campo de clase myCallback ? En este momento, el campo público myCallback es de tipo any como se muestra arriba. ¿Cómo puedo definir la firma de método de la devolución de llamada? ¿O puedo simplemente configurar el tipo para algún tipo de devolución de llamada? ¿O puedo hacer más abajo de estos? ¿Debo usar any (implícito / explícito)?

Intenté algo así, pero no funcionó (error en tiempo de compilación):

public myCallback: ();
// or:
public myCallback: function;

No pude encontrar ninguna explicación para esto en línea, así que espero que me puedan ayudar.

Answer 1

Acabo de encontrar algo en la especificación del lenguaje TypeScript, es bastante fácil. Estaba bastante cerca.

la sintaxis es la siguiente:

public myCallback: (name: type) => returntype;

En mi ejemplo, sería

class CallbackTest
{
    public myCallback: () => void;

    public doWork(): void
    {
        //doing some work...
        this.myCallback(); //calling callback
    }
}

Answer 2

Aquí hay un ejemplo: no acepta ningún parámetro y no devuelve nada.

class CallbackTest
{
    public myCallback: {(): void;};

    public doWork(): void
    {
        //doing some work...
        this.myCallback(); //calling callback
    }
}

var test = new CallbackTest();
test.myCallback = () => alert("done");
test.doWork();

Si quiere aceptar un parámetro, puede agregarlo también:

public myCallback: {(msg: string): void;};

Y si desea devolver un valor, puede agregarlo también:

public myCallback: {(msg: string): number;};

Answer 3

Encontré el mismo error al intentar agregar la devolución de llamada a un detector de eventos. Curiosamente, la configuración del tipo de devolución de llamada a EventListener lo resolvió. Parece más elegante que definir una firma de función completa como un tipo, pero no estoy seguro de si esta es la forma correcta de hacerlo.

class driving {
    // the answer from this post - this works
    // private callback: () => void; 

    // this also works!
    private callback:EventListener;

    constructor(){
        this.callback = () => this.startJump();
        window.addEventListener("keydown", this.callback);
    }

    startJump():void {
        console.log("jump!");
        window.removeEventListener("keydown", this.callback);
    }
}

Answer 4

Para ir un paso más allá, puede declarar un puntero de tipo a una firma de función como:

interface myCallbackType { (myArgument: string): void }

y úsalo así:

public myCallback : myCallbackType;

Answer 5

Puedes declarar un nuevo tipo:

declare type MyHandler = (myArgument: string) => void;

var handler: MyHandler;

Actualizar.

La palabra clave declare no es necesaria. Debería usarse en los archivos .d.ts o en casos similares.

Answer 6

Si desea una función genérica, puede usar lo siguiente. Aunque no parece estar documentado en ninguna parte.

class CallbackTest {
  myCallback: Function;
}