Les fonctions fortement typées en tant que paramètres sont-elles possibles dans TypeScript?

Question

À la Machine, je peux déclarer un paramètre d'une fonction comme une Fonction de type. Est-il un "type-safe" façon de faire ce qui me manque? Par exemple, considérez ceci:

class Foo {
    save(callback: Function) : void {
        //Do the save
        var result : number = 42; //We get a number from the save operation
        //Can I at compile-time ensure the callback accepts a single parameter of type number somehow?
        callback(result);
    }
}

var foo = new Foo();
var callback = (result: string) : void => {
    alert(result);
}
foo.save(callback);

Le sauver de rappel n'est pas de type coffre-fort, je suis lui donnant une fonction de rappel où le paramètre de la fonction est une chaîne, mais je suis de passage d'un certain nombre, et compile sans erreurs. Puis-je faire le paramètre de résultat en enregistrer un type de fonction de sécurité?

tl;dr version: existe-il un équivalent de un .NET délégué à la Machine?

Answer 1

Sûr:

 class Foo {
    save(callback: (n: number) => any) : void {
        callback(42);
    }
}
var foo = new Foo();

var strCallback = (result: string) : void => {
    alert(result);
}
var numCallback = (result: number) : void => {
    alert(result.toString());
}

foo.save(strCallback); // not OK
foo.save(numCallback); // OK
 

Si vous le souhaitez, vous pouvez créer une interface pour encapsuler ceci:

 interface NumberCallback {
    (n: number): any;   
}

class Foo {
    // Equivalent
    save(callback: NumberCallback) : void {
        callback(42);
    }
}
 

Answer 2

Voici les équivalents TypeScript de certains délégués .NET courants:

 interface Action<T>
{
    (item: T): void;
}

interface Func<T,TResult>
{
    (item: T): TResult;
}