Le funzioni fortemente tipizzate come parametri sono possibili in TypeScript?

In TypeScript, posso dichiarare un parametro di una funzione come tipo Funzione. Esiste un modo "sicuro di scrivere" per fare ciò che mi manca? Ad esempio, considera questo:

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

Il callback di salvataggio non è di tipo sicuro, le sto assegnando una funzione di callback in cui il parametro della funzione è una stringa ma le sto passando un numero e lo compilo senza errori. Posso salvare il parametro risultato in una funzione di tipo sicuro?

TL; versione DR: esiste un equivalente di un delegato .NET in TypeScript?

Sicuro. Il tipo di una funzione è costituito dai tipi del suo argomento e dal suo tipo restituito. Qui specifichiamo che il callbacktipo di parametro deve essere "funzione che accetta un numero e restituisce il tipo 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

Se vuoi, puoi definire un tipo alias per incapsulare questo:

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

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

Ecco gli equivalenti TypeScript di alcuni delegati .NET comuni:

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

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

Mi rendo conto che questo post è vecchio, ma esiste un approccio più compatto leggermente diverso da quello che è stato chiesto, ma potrebbe essere un'alternativa molto utile. È possibile dichiarare essenzialmente la funzione in-line quando si chiama il metodo ( Foo's save()in questo caso). Sarebbe simile a questo:

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()approccio è molto utile per cose come le chiamate di rete che potrebbero avere esito positivo o negativo. Sempre assumendo un esempio di chiamata di rete, quandomultipleCallbacks() viene chiamato, il comportamento sia per un successo che per un fallimento può essere definito in un punto, il che si presta a una maggiore chiarezza per i futuri lettori di codici.

In generale, nella mia esperienza, questo approccio si presta ad essere più conciso, meno disordinato e una maggiore chiarezza generale.

Buona fortuna a tutti!

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

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

Questo sicuramente si allinea al paradigma di programmazione funzionale.

In TS possiamo digitare le funzioni nei seguenti modi:

Tipi di funzioni / firme

Questo è usato per implementazioni reali di funzioni / metodi ha la seguente sintassi:

(arg1: Arg1type, arg2: Arg2type) : ReturnType

Esempio:

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

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

}

Tipo di funzione letterali

I letterali del tipo di funzione sono un altro modo per dichiarare il tipo di funzione. Di solito vengono applicati nella firma della funzione di una funzione di ordine superiore. Una funzione di ordine superiore è una funzione che accetta funzioni come parametri o che restituisce una funzione. Ha la seguente sintassi:

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

Esempio:

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

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

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

}

Se si definisce prima il tipo di funzione, sarebbe simile

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

Senza il tipo di funzione usando la sintassi della proprietà plain sarebbe:

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

Se si desidera utilizzare una funzione di interfaccia come i delegati generici c # sarebbe:

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

Oltre a quanto affermato da altri, un problema comune è dichiarare i tipi della stessa funzione sovraccaricata. Il caso tipico è il metodo EventEmitter on () che accetta più tipi di listener. Simile potrebbe accadere quando si lavora con azioni redux - e lì si utilizza il tipo di azione come letterale per contrassegnare il sovraccarico, in caso di EventEmitters, si utilizza il tipo letterale di nome evento:

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