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 un message comme prévu.

Ma question est la suivante: existe-t-il un type que je peux fournir pour mon champ de classe myCallback ? À l’heure actuelle, le champ public myCallback est de type any comme indiqué ci-dessus. Comment définir la signature de la méthode du rappel? Ou puis-je simplement définir le type sur une sorte de type de rappel? Ou puis-je en faire moins? Dois-je en utiliser (implicite / explicite)?

J’ai essayé quelque chose comme ça, mais ça n’a pas fonctionné (erreur à la 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 facile. 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 à une signature de fonction comme:

 interface myCallbackType { (myArgument: ssortingng): void } 

et l’utiliser comme ceci:

 public myCallback : myCallbackType; 

Vous pouvez déclarer un nouveau type:

 declare type MyHandler = (myArgument: ssortingng) => void; var handler: MyHandler; 

Mettre à jour.

Le mot-clé declare n’est pas nécessaire. Il devrait être utilisé dans les fichiers .d.ts ou dans des cas similaires.

Voici un exemple: 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’append:

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

Et si vous souhaitez renvoyer une valeur, vous pouvez également l’append:

 public myCallback: {(msg: ssortingng): 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; } 

J’ai rencontré la même erreur en essayant d’append le rappel à un écouteur d’événement. Étrangement, la définition du type de rappel sur EventListener a résolu le problème. 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 manière correcte de le 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); } }