Sind stark typisierte Funktionen als Parameter in TypeScript möglich?

In TypeScript kann ich einen Parameter einer Funktion als Typfunktion deklarieren. Gibt es eine "typsichere" Möglichkeit, die mir fehlt? Betrachten Sie zum Beispiel Folgendes:

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

Der Rückruf zum Speichern ist nicht typsicher. Ich gebe ihm eine Rückruffunktion, bei der der Parameter der Funktion eine Zeichenfolge ist, aber ich übergebe ihm eine Nummer und kompiliere ohne Fehler. Kann ich den Ergebnisparameter beim Speichern einer typsicheren Funktion festlegen?

TL; DR-Version: Gibt es ein Äquivalent zu einem .NET-Delegaten in TypeScript?

Sicher. Der Typ einer Funktion besteht aus den Typen ihres Arguments und ihrem Rückgabetyp. Hier geben wir an, dass der callbackTyp des Parameters "Funktion, die eine Zahl akzeptiert und Typ zurückgibt any" sein muss:

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

Wenn Sie möchten, können Sie einen Typalias definieren , um dies zu kapseln:

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

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

Hier sind TypeScript-Entsprechungen einiger gängiger .NET-Delegaten:

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

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

Mir ist klar, dass dieser Beitrag alt ist, aber es gibt einen kompakteren Ansatz, der sich geringfügig von dem unterscheidet, was gefragt wurde, aber möglicherweise eine sehr hilfreiche Alternative darstellt. Sie können die Funktion im Wesentlichen inline deklarieren, wenn Sie die Methode aufrufen ( in diesem Fall Foos save()). Es würde ungefähr so ​​aussehen:

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

Der multipleCallback()Ansatz ist sehr nützlich für Dinge wie Netzwerkanrufe, die erfolgreich sein oder fehlschlagen können. Unter der Annahme eines Beispiels multipleCallbacks()für einen Netzwerkaufruf kann beim Aufruf das Verhalten für Erfolg und Misserfolg an einer Stelle definiert werden, was für zukünftige Codeleser zu größerer Klarheit führt.

Nach meiner Erfahrung bietet sich dieser Ansatz im Allgemeinen an, um prägnanter, weniger übersichtlich und insgesamt klarer zu sein.

Viel Glück euch allen!

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

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

Dies stimmt sicherlich mit dem funktionalen Programmierparadigma überein.

In TS können wir Funktionen auf folgende Weise eingeben:

Funktionstypen / Signaturen

Dies wird für reale Implementierungen von Funktionen / Methoden verwendet und hat die folgende Syntax:

(arg1: Arg1type, arg2: Arg2type) : ReturnType

Beispiel:

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

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

}

Funktionstyp-Literale

Funktionstyp-Literale sind eine weitere Möglichkeit, den Typ einer Funktion zu deklarieren. Sie werden normalerweise in der Funktionssignatur einer Funktion höherer Ordnung angewendet. Eine Funktion höherer Ordnung ist eine Funktion, die Funktionen als Parameter akzeptiert oder eine Funktion zurückgibt. Es hat die folgende Syntax:

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

Beispiel:

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

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

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

}

Wenn Sie zuerst den Funktionstyp definieren, sieht er so aus

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

Ohne Funktionstyp unter Verwendung der einfachen Eigenschaftssyntax wäre dies:

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

Wenn Sie eine Schnittstellenfunktion wie generische c # -Delegierte verwenden möchten, wäre dies:

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

Neben dem, was andere sagten, besteht ein häufiges Problem darin, die Typen derselben Funktion zu deklarieren, die überladen sind. Ein typischer Fall ist die EventEmitter on () -Methode, die mehrere Arten von Listenern akzeptiert. Ähnliches kann passieren, wenn Sie mit Redux-Aktionen arbeiten - und dort verwenden Sie den Aktionstyp als Literal, um die Überladung zu markieren. Bei EventEmitters verwenden Sie den Literaltyp Ereignisname:

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