Definieren des TypeScript-Rückruftyps

Ich habe die folgende Klasse in TypeScript:

class CallbackTest
{
    public myCallback;

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

Ich benutze die Klasse wie folgt:

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

Der Code funktioniert und zeigt erwartungsgemäß ein Meldungsfeld an.

Meine Frage ist: Gibt es einen Typ, den ich für mein Klassenfeld bereitstellen kann myCallback? Im Moment ist das öffentliche Feld myCallbackvom Typ anywie oben gezeigt. Wie kann ich die Methodensignatur des Rückrufs definieren? Oder kann ich den Typ einfach auf einen Rückruftyp einstellen? Oder kann ich beides tun? Muss ich verwenden any(implizit / explizit)?

Ich habe so etwas versucht, aber es hat nicht funktioniert (Fehler beim Kompilieren):

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

Ich konnte online keine Erklärung dafür finden, also hoffe ich, dass Sie mir helfen können.

Ich habe gerade etwas in der TypeScript-Sprachspezifikation gefunden, es ist ziemlich einfach. Ich war ziemlich nah dran.

Die Syntax lautet wie folgt:

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

In meinem Beispiel wäre es

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

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

Um noch einen Schritt weiter zu gehen, können Sie einen Typzeiger auf eine Funktionssignatur wie folgt deklarieren:

interface myCallbackType { (myArgument: string): void }

und benutze es so:

public myCallback : myCallbackType;

Sie können einen neuen Typ deklarieren:

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

var handler: MyHandler;

Aktualisieren.

Das declareSchlüsselwort ist nicht erforderlich. Es sollte in den .d.ts-Dateien oder in ähnlichen Fällen verwendet werden.

Hier ist ein Beispiel: Akzeptieren Sie keine Parameter und geben Sie nichts zurück.

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

Wenn Sie einen Parameter akzeptieren möchten, können Sie diesen auch hinzufügen:

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

Und wenn Sie einen Wert zurückgeben möchten, können Sie diesen auch hinzufügen:

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

Wenn Sie eine generische Funktion wünschen, können Sie Folgendes verwenden. Obwohl es nirgendwo dokumentiert zu sein scheint.

class CallbackTest {
  myCallback: Function;
}   

Sie können Folgendes verwenden:

1. Typ Alias ​​(mit typeSchlüsselwort, Aliasing eines Funktionsliteral)
2. Schnittstelle
3. Funktionsliteral

Hier ist ein Beispiel für deren Verwendung:

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;

    // ...

}

Beim Versuch, den Rückruf einem Ereignis-Listener hinzuzufügen, ist derselbe Fehler aufgetreten. Seltsamerweise wurde das Problem behoben, indem der Rückruftyp auf EventListener gesetzt wurde. Es sieht eleganter aus, als eine ganze Funktionssignatur als Typ zu definieren, aber ich bin mir nicht sicher, ob dies der richtige Weg ist.

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

Ich bin etwas spät dran, aber seit einiger Zeit können Sie in TypeScript die Art des Rückrufs mit definieren

type MyCallback = (KeyboardEvent) => void;

Anwendungsbeispiel:

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

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