在TypeScript中，强类型函数可以作为参数吗？

在TypeScript中，我可以将函数的参数声明为类型Function。是否有我缺少的“类型安全”方法？例如，考虑一下：

class Foo {save(callback: Function) : void {//Do the savevar 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);

保存回调不是类型安全的，我给它一个回调函数，其中函数的参数是一个字符串，但我传递了一个数字，并编译没有错误。我可以在保存类型安全函数中设置结果参数吗？

太长别读版本：TypeScript中是否有相当于. NET委托的版本？

503213 次浏览
小开
最佳答案

当然。函数的类型由其参数类型和返回类型组成。这里我们指定callback参数的类型必须是“接受数字并返回类型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 OKfoo.save(numCallback); // OK

如果你愿意，你可以定义一个类型别名来封装它：

type NumberCallback = (n: number) => any;
class Foo {// Equivalentsave(callback: NumberCallback) : void {callback(42);}}
小开

以下是一些常见的TypeScript等效。NET委托：

interface Action<T>{(item: T): void;}
interface Func<T,TResult>{(item: T): TResult;}
小开

我意识到这篇文章是旧的，但有一种更紧凑的方法，与所问的略有不同，但可能是一个非常有用的替代方案。你可以在调用方法时基本上声明函数内联（在这种情况下是Foo的save()）。它看起来像这样：

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

multipleCallback()方法对于可能成功或失败的网络调用等事情非常有用。再次假设一个网络调用示例，当调用multipleCallbacks()时，成功和失败的行为都可以在一个地方定义，这有助于未来的代码读者更加清晰。

一般来说，根据我的经验，这种方法本身更简洁，更少混乱，整体更清晰。

祝大家好运！

小开 
type FunctionName = (n: inputType) => any;
class ClassName {save(callback: FunctionName) : void {callback(data);}}

这当然与函数式编程范式一致。

小开

如果你先定义函数类型，那么它看起来就像

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 errorfoo.save(numberCallback);

如果没有使用纯属性语法的函数类型，它将是：

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 errorfoo.save(numberCallback);

如果你想使用像c#泛型委托这样的接口函数，它将是：

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 errorfoo.save(numberCBObj);
小开

在TS中，我们可以通过以下方式键入函数：

函数类型/签名

这用于函数/方法的实际实现，它具有以下语法：

(arg1: Arg1type, arg2: Arg2type) : ReturnType

示例：

function add(x: number, y: number): number {return x + y;}
class Date {setTime(time: number): number {// ...}
}

函数类型文字

函数类型文字是声明函数类型的另一种方式。它们通常应用于高阶函数的函数签名中。高阶函数是接受函数作为参数或返回函数的函数。它具有以下语法：

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

示例：

type FunctionType1 = (x: string, y: number) => number;
class Foo {save(callback: (str: string) => void) {// ...}
doStuff(callback: FunctionType1) {// ...}
}
小开

除了其他人所说的，一个常见的问题是声明重载的相同函数的类型。典型的情况是EventEmitter on（）方法，它将接受多种侦听器。当使用redux操作时可能会发生类似的情况-在那里你使用操作类型作为文字来标记重载，在EventEmitters的情况下，你使用事件名称文本类型：

interface MyEmitter extends EventEmitter {on(name:'click', l: ClickListener):voidon(name:'move', l: MoveListener):voidon(name:'die', l: DieListener):void//and a generic oneon(name:string, l:(...a:any[])=>any):void}
type ClickListener = (e:ClickEvent)=>voidtype MoveListener = (e:MoveEvent)=>void... etc
// will type check the correct listener when writing something like:myEmitter.on('click', e=>...<--- autocompletion
小开

因为你不能轻易地将一个函数定义和另一个数据类型结合起来，所以我发现拥有这些类型对于强键入它们很有用。基于Drew的回答。

type Func<TArgs extends any[], TResult> = (...args: TArgs) => TResult;//Syntax sugartype Action<TArgs extends any[]> = Func<TArgs, undefined>;

现在您可以强键入每个参数和返回类型！这是一个比上面更多参数的示例。

save(callback: Func<[string, Object, boolean], number>): number{let str = "";let obj = {};let bool = true;let result: number = callback(str, obj, bool);return result;}

现在您可以编写联合类型，例如返回对象的对象或函数，而无需创建可能需要导出或使用的全新类型。

//THIS DOESN'T WORKlet myVar1: boolean | (parameters: object) => boolean;
//This works, but requires a type be defined each timetype myBoolFunc = (parameters: object) => boolean;let myVar1: boolean | myBoolFunc;
//This works, with a generic type that can be used anywherelet myVar2: boolean | Func<[object], boolean>;
小开 
function callbackTesting(callbacks: {onYes: (data: any) => void,onNo: (data: any) => void,onError: (err: any) => void,}, type: String){switch(type){case "one":callbacks.onYes("Print yes");break;case "two":callbacks.onNo("Print no");break;default:callbacks.onError("Print error");break;}}
const onYes1 = (data: any) : void => {console.log(data);}const onNo1 = (data: any) : void => {console.log(data);}const onError1 = (data: any) : void => {console.log(data);}


callbackTesting({onYes: function (data: any)  {onYes1(data);},onNo: function (data: any)  {onNo1(data);},onError: function (data: any)  {onError1(data);}}, "one");
callbackTesting({onYes: function (data: any)  {onYes1(data);},onNo: function (data: any)  {onNo1(data);},onError: function (data: any)  {onError1(data);}}, "two");
callbackTesting({onYes: function (data: any)  {onYes1(data);},onNo: function (data: any)  {onNo1(data);},onError: function (data: any)  {onError1(data);}}, "cfhvgjbhkjlkm");

提交答案