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

Dans TypeScript, je peux déclarer un paramètre d'une fonction en tant que type Function. Existe-t-il un moyen «sûr de type» de faire cela 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 rappel de sauvegarde n'est pas de type sécurisé, je lui donne une fonction de rappel où le paramètre de la fonction est une chaîne mais je lui passe un nombre et compile sans erreur. Puis-je faire le paramètre de résultat dans enregistrer une fonction de type sécurisé?

Version TL; DR: existe-t-il un équivalent d'un délégué .NET en TypeScript?

Sûr. Le type d' une fonction se compose des types de son argument et de son type de retour. Ici, nous spécifions que le callbacktype du paramètre doit être "fonction qui accepte un nombre et renvoie un type any":

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 définir un alias de type pour encapsuler ceci:

type NumberCallback = (n: number) => any;

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

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

Je me rends compte que ce message est ancien, mais il existe une approche plus compacte légèrement différente de ce qui a été demandé, mais peut être une alternative très utile. Vous pouvez essentiellement déclarer la fonction en ligne lors de l' appel de la méthode ( Foo« s save()dans ce cas). Cela ressemblerait à quelque chose comme ceci:

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

    multipleCallbacks(firstCallback: (s: string) => void, secondCallback: (b: boolean) => boolean): void {
        firstCallback("hello world")

        let result: boolean = secondCallback(true)
        console.log("Resulting boolean: " + result)
    }
}

var foo = new Foo()

// Single callback example.
// Just like with @RyanCavanaugh's approach, ensure the parameter(s) and return
// types match the declared types above in the `save()` method definition.
foo.save((newNumber: number) => {
    console.log("Some number: " + newNumber)

    // This is optional, since "any" is the declared return type.
    return newNumber
})

// Multiple callbacks example.
// Each call is on a separate line for clarity.
// Note that `firstCallback()` has a void return type, while the second is boolean.
foo.multipleCallbacks(
    (s: string) => {
         console.log("Some string: " + s)
    },
    (b: boolean) => {
        console.log("Some boolean: " + b)
        let result = b && false

        return result
    }
)

L' multipleCallback()approche est très utile pour des choses comme les appels réseau qui peuvent réussir ou échouer. En supposant à nouveau un exemple d'appel réseau, lorsqu'il multipleCallbacks()est appelé, le comportement à la fois pour un succès et un échec peut être défini en un seul endroit, ce qui se prête à une plus grande clarté pour les futurs lecteurs de code.

En général, d'après mon expérience, cette approche se prête à être plus concise, moins encombrante et plus claire dans l'ensemble.

Bonne chance à tous!

type FunctionName = (n: inputType) => any;

class ClassName {
    save(callback: FunctionName) : void {
        callback(data);
    }
}

Cela correspond certainement au paradigme de programmation fonctionnelle.

Dans TS, nous pouvons taper les fonctions de la manière suivante:

Types de fonctions / signatures

Ceci est utilisé pour des implémentations réelles de fonctions / méthodes, il a la syntaxe suivante:

(arg1: Arg1type, arg2: Arg2type) : ReturnType

Exemple:

function add(x: number, y: number): number {
    return x + y;
}

class Date {
  setTime(time: number): number {
   // ...
  }

}

Type de fonction Littéraux

Les littéraux de type de fonction sont une autre façon de déclarer le type d'une fonction. Ils sont généralement appliqués dans la signature de fonction d'une fonction d'ordre supérieur. Une fonction d'ordre supérieur est une fonction qui accepte des fonctions comme paramètres ou qui renvoie une fonction. Il a la syntaxe suivante:

(arg1: Arg1type, arg2: Arg2type) => ReturnType

Exemple:

type FunctionType1 = (x: string, y: number) => number;

class Foo {
    save(callback: (str: string) => void) {
       // ...
    }

    doStuff(callback: FunctionType1) {
       // ...
    }

}

Si vous définissez d'abord le type de fonction, il ressemblerait à

type Callback = (n: number) => void;

class Foo {
    save(callback: Callback) : void {        
        callback(42);
    }
}

var foo = new Foo();
var stringCallback = (result: string) : void => {
    console.log(result);
}

var numberCallback = (result: number) : void => {
    console.log(result);
}

foo.save(stringCallback); //--will be showing error
foo.save(numberCallback);

Sans type de fonction en utilisant la syntaxe de propriété simple, ce serait:

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

var foo = new Foo();
var stringCallback = (result: string) : void => {
    console.log(result);
}

var numberCallback = (result: number) : void => {
    console.log(result);
}

foo.save(stringCallback); //--will be showing error
foo.save(numberCallback);

Si vous voulez en utilisant une fonction d'interface comme les délégués génériques c #, ce serait:

interface CallBackFunc<T, U>
{
    (input:T): U;
};

class Foo {
    save(callback: CallBackFunc<number,void>) : void {        
        callback(42);
    }
}

var foo = new Foo();
var stringCallback = (result: string) : void => {
    console.log(result);
}

var numberCallback = (result: number) : void => {
    console.log(result);
}

let strCBObj:CallBackFunc<string,void> = stringCallback;
let numberCBObj:CallBackFunc<number,void> = numberCallback;

foo.save(strCBObj); //--will be showing error
foo.save(numberCBObj);

Outre ce que d'autres ont dit, un problème commun est de déclarer les types de la même fonction qui est surchargée. Le cas typique est la méthode EventEmitter on () qui accepte plusieurs types d'écouteurs. Une situation similaire peut se produire lorsque vous travaillez avec des actions redux - et là, vous utilisez le type d'action comme littéral pour marquer la surcharge. Dans le cas d'EventEmitters, vous utilisez le type littéral du nom de l'événement:

interface MyEmitter extends EventEmitter {
  on(name:'click', l: ClickListener):void
  on(name:'move', l: MoveListener):void
  on(name:'die', l: DieListener):void
  //and a generic one
  on(name:string, l:(...a:any[])=>any):void
}

type ClickListener = (e:ClickEvent)=>void
type MoveListener = (e:MoveEvent)=>void
... etc

// will type check the correct listener when writing something like:
myEmitter.on('click', e=>...<--- autocompletion