Definizione del tipo di callback TypeScript

Ho la seguente classe in TypeScript:

class CallbackTest
{
    public myCallback;

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

Sto usando la classe in questo modo:

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

Il codice funziona, quindi visualizza una finestra di messaggio come previsto.

La mia domanda è: esiste un tipo che posso fornire per il mio campo di classe myCallback? In questo momento, il campo pubblico myCallbackè di tipo anycome mostrato sopra. Come posso definire la firma del metodo del callback? O posso semplicemente impostare il tipo su un tipo di callback-type? O posso fare il nether di questi? Devo usare any(implicito / esplicito)?

Ho provato qualcosa del genere, ma non ha funzionato (errore di compilazione):

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

Non sono riuscito a trovare alcuna spiegazione online, quindi spero che tu mi possa aiutare.

Ho appena trovato qualcosa nelle specifiche del linguaggio TypeScript, è abbastanza semplice. Ero abbastanza vicino.

la sintassi è la seguente:

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

Nel mio esempio, lo sarebbe

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

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

Per fare un ulteriore passo, è possibile dichiarare un puntatore tipo a una firma di funzione come:

interface myCallbackType { (myArgument: string): void }

e usalo così:

public myCallback : myCallbackType;

Puoi dichiarare un nuovo tipo:

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

var handler: MyHandler;

Aggiornare.

La declareparola chiave non è necessaria. Dovrebbe essere usato nei file .d.ts o in casi simili.

Ecco un esempio: non accettare parametri e non restituire nulla.

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

Se si desidera accettare un parametro, è possibile aggiungere anche quello:

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

E se si desidera restituire un valore, è possibile aggiungere anche quello:

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

Se si desidera una funzione generica, è possibile utilizzare quanto segue. Anche se non sembra essere documentato da nessuna parte.

class CallbackTest {
  myCallback: Function;
}   

È possibile utilizzare quanto segue:

1. Digitare alias (usando la typeparola chiave, alias di una funzione letterale)
2. Interfaccia
3. Funzione letterale

Ecco un esempio di come usarli:

type myCallbackType = (arg1: string, arg2: boolean) => number;

interface myCallbackInterface { (arg1: string, arg2: boolean): number };

class CallbackTest
{
    // ...

    public myCallback2: myCallbackType;
    public myCallback3: myCallbackInterface;
    public myCallback1: (arg1: string, arg2: boolean) => number;

    // ...

}

Mi sono imbattuto nello stesso errore durante il tentativo di aggiungere il callback a un listener di eventi. Stranamente, risolvendo il tipo di callback su EventListener. Sembra più elegante della definizione di una firma di intera funzione come tipo, ma non sono sicuro che questo sia il modo corretto per farlo.

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

Sono un po 'in ritardo, ma da qualche tempo in TypeScript è possibile definire il tipo di callback con

type MyCallback = (KeyboardEvent) => void;

Esempio di utilizzo:

this.addEvent(document, "keydown", (e) => {
    if (e.keyCode === 1) {
      e.preventDefault();
    }
});

addEvent(element, eventName, callback: MyCallback) {
    element.addEventListener(eventName, callback, false);
}