Apakah fungsi yang diketik dengan kuat sebagai parameter mungkin dalam TypeScript?

Di TypeScript, saya bisa mendeklarasikan parameter fungsi sebagai tipe Function. Apakah ada cara "aman untuk" melakukan hal ini yang saya lewatkan? Sebagai contoh, pertimbangkan ini:

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

Simpan callback bukan tipe aman, saya memberinya fungsi callback di mana parameter fungsi adalah string tetapi saya meneruskannya nomor, dan mengkompilasi tanpa kesalahan. Bisakah saya membuat parameter hasil dalam menyimpan fungsi tipe-aman?

TL; Versi DR: apakah ada yang setara dengan delegasi .NET di TypeScript?

Tentu. Tipe fungsi terdiri dari tipe argumennya dan tipe pengembaliannya. Di sini kami menentukan bahwa tipe callbackparameter harus "fungsi yang menerima nomor dan mengembalikan tipe 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

Jika mau, Anda dapat menentukan jenis alias untuk merangkum ini:

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

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

Berikut ini adalah setara dengan TypeScript dari beberapa delegasi .NET umum:

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

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

Saya menyadari posting ini sudah tua, tetapi ada pendekatan yang lebih kompak yang sedikit berbeda dari yang diminta, tetapi mungkin merupakan alternatif yang sangat membantu. Anda pada dasarnya dapat mendeklarasikan fungsi in-line saat memanggil metode ( Foo's save()dalam kasus ini). Akan terlihat seperti ini:

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

The multipleCallback()Pendekatan ini sangat berguna untuk hal-hal seperti panggilan jaringan yang mungkin berhasil atau gagal. Sekali lagi dengan asumsi contoh panggilan jaringan, kapanmultipleCallbacks() dipanggil, perilaku untuk sukses dan gagal dapat didefinisikan di satu tempat, yang cocok untuk kejelasan yang lebih besar bagi pembaca kode masa depan.

Secara umum, dalam pengalaman saya, pendekatan ini cocok untuk menjadi lebih ringkas, kurang berantakan, dan lebih jelas secara keseluruhan.

Semoga beruntung semuanya!

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

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

Ini tentunya sejalan dengan paradigma pemrograman fungsional.

Di TS kita bisa mengetikkan fungsi-fungsi di dalam tata cara berikut:

Jenis fungsi / tanda tangan

Ini digunakan untuk implementasi nyata dari fungsi / metode yang memiliki sintaksis berikut:

(arg1: Arg1type, arg2: Arg2type) : ReturnType

Contoh:

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

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

}

Tipe Fungsi Literal

Literal tipe fungsi adalah cara lain untuk mendeklarasikan tipe fungsi. Mereka biasanya diterapkan dalam tanda tangan fungsi dari fungsi tingkat tinggi. Fungsi tingkat tinggi adalah fungsi yang menerima fungsi sebagai parameter atau yang mengembalikan fungsi. Ini memiliki sintaks berikut:

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

Contoh:

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

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

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

}

Jika Anda menentukan jenis fungsi terlebih dahulu maka akan terlihat seperti

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

Tanpa tipe fungsi dengan menggunakan sintaks properti biasa akan menjadi:

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

Jika Anda ingin menggunakan fungsi antarmuka seperti delegasi c # generiknya adalah:

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

Selain apa yang dikatakan orang lain, masalah umum adalah mendeklarasikan jenis fungsi yang sama yang kelebihan beban. Kasus umum adalah metode EventEmitter on () yang akan menerima beberapa jenis pendengar. Serupa bisa terjadi Ketika bekerja dengan aksi redux - dan di sana Anda menggunakan tipe tindakan sebagai literal untuk menandai kelebihan beban, Jika CaseEmitters, Anda menggunakan tipe literal nama acara:

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