Définition du type de rappel TypeScript

J'ai la classe suivante dans TypeScript:

class CallbackTest
{
    public myCallback;

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

J'utilise la classe comme ceci:

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

Le code fonctionne, il affiche donc une boîte de message comme prévu.

Ma question est la suivante: y a-t-il un type que je peux fournir pour mon champ de classe myCallback? À l'heure actuelle, le champ public myCallbackest du type anyindiqué ci-dessus. Comment puis-je définir la signature de méthode du callback? Ou puis-je simplement définir le type sur une sorte de type de rappel? Ou puis-je faire rien de tout cela? Dois-je utiliser any(implicite / explicite)?

J'ai essayé quelque chose comme ça, mais cela n'a pas fonctionné (erreur de compilation):

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

Je n'ai trouvé aucune explication à cela en ligne, alors j'espère que vous pourrez m'aider.

Je viens de trouver quelque chose dans la spécification du langage TypeScript, c'est assez simple. J'étais assez proche.

la syntaxe est la suivante:

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

Dans mon exemple, ce serait

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

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

Pour aller plus loin, vous pouvez déclarer un pointeur de type vers une signature de fonction comme:

interface myCallbackType { (myArgument: string): void }

et utilisez-le comme ceci:

public myCallback : myCallbackType;

Vous pouvez déclarer un nouveau type:

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

var handler: MyHandler;

Mettre à jour.

Le declaremot-clé n'est pas nécessaire. Il doit être utilisé dans les fichiers .d.ts ou dans des cas similaires.

Voici un exemple - n'accepter aucun paramètre et ne rien renvoyer.

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 vous souhaitez accepter un paramètre, vous pouvez également l'ajouter:

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

Et si vous souhaitez renvoyer une valeur, vous pouvez également l'ajouter:

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

Si vous voulez une fonction générique, vous pouvez utiliser ce qui suit. Bien que cela ne semble pas être documenté nulle part.

class CallbackTest {
  myCallback: Function;
}   

Vous pouvez utiliser les éléments suivants:

1. Tapez Alias ​​(en utilisant type mot-clé, aliasing un littéral de fonction)
2. Interface
3. Fonction littérale

Voici un exemple de leur utilisation:

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;

    // ...

}

Je suis tombé sur la même erreur en essayant d'ajouter le rappel à un écouteur d'événements. Étrangement, définir le type de rappel sur EventListener l'a résolu. Cela semble plus élégant que de définir une signature de fonction entière en tant que type, mais je ne suis pas sûr que ce soit la bonne façon de faire.

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

Je suis un peu en retard, mais depuis quelque temps dans TypeScript vous pouvez définir le type de rappel avec

type MyCallback = (KeyboardEvent) => void;

Exemple d'utilisation:

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

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