强类型函数是否可以作为TypeScript中的参数？

在TypeScript中，我可以将函数的参数声明为类型函数。是否有一种“类型安全”的方法可以做到这一点，而我却没有？例如，考虑这一点：

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

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

TL；DR版本：TypeScript中是否有与.NET委托等效的代理？

当然。函数的类型由其参数类型和返回类型组成。这里我们指定

回调

参数的类型必须是“接受数字并返回类型

任意

的函数”：

如果需要，可以定义一个用于封装此文件的：

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

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

---

以下是一些常见.NET委托的TypeScript等价物：

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

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

接口动作
{
（项目：T）：无效；
}
接口函数
{
（项目：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 error
foo.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 error
foo.save(numberCallback);

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

如果您想使用像c#generic delegate这样的接口函数，它将是：

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

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

接口调用函数
{
（输入：T）：U；
};
福班{
保存（回调：CallBackFunc）：void{
回收（42）；
}
}
var foo=new foo（）；
var stringCallback=（结果：string）：void=>{
控制台日志（结果）；
}
var numberCallback=（结果：number）：void=>{
控制台日志（结果）；
}
让strcbobbj:CallBackFunc=stringCallback；
let numberCBObj:CallBackFunc=numberCallback；
foo.save（strCBObj）//--将显示错误
foo.save（numberCBObj）；

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

函数类型/签名

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

(arg1: Arg1type, arg2: Arg2type) : ReturnType

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

示例：

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

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

}

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

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

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

}

函数类型文本

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

(arg1: Arg1type, arg2: Arg2type) : ReturnType

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

示例：

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

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

}

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

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

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

}

---

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

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

接口MyEmitter扩展了EventEmitter{
on（名称：'click'，l:ClickListener）：无效
on（名称：'move'，l:MoveListener）：无效
on（名称：'die'，l:DieListener）：无效
//还有一个普通的
on（name:string，l:（…a:any[]）=>any:void
}
键入ClickListener=（e:ClickEvent）=>void
类型MoveListener=（e:MoveEvent）=>void
... 等
//在编写以下内容时，将键入检查正确的侦听器：
MyMitter.on（'click'，e=>…因为您无法轻松地将函数定义与另一个数据类型合并，所以我发现使用这些类型对强类型非常有用。基于Drew的回答

type Func=（…args:TArgs）=>TResult；
//语法糖
类型Action=Func；

现在，您可以强键入每个参数和返回类型！下面是一个示例，其中包含的参数比上面的更多

save（回调：Func）：编号
{
设str=“”；
设obj={}；
让布尔=真；
let结果：number=callback（str、obj、bool）；
返回结果；
}

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

//这不起作用
让myVar1:boolean |（参数：object）=>boolean；
//这是可行的，但每次都需要定义一个类型
键入myBoolFunc=（参数：object）=>boolean；
设myVar1:boolean | myBoolFunc；
//这是可行的，因为泛型类型可以在任何地方使用
设myVar2:boolean | Func；

函数回调测试（回调：{onYes:（data:any）=>void，onNo:（data:any）=>void，onError:（err:any）=>void，}，类型：String）{
开关（类型）{
案例“一”：
回调。onYes（“打印是”）；
打破
案例“二”：
回调。onNo（“打印号”）；
打破
违约：
callbacks.onError（“打印错误”）；
打破
}
}
常量1=（数据：任意）：void=>{
控制台日志（数据）；
}
const onNo1=（数据：any）：void=>{
控制台日志（数据）；
}
const onError1=（数据：任意）：void=>{
控制台日志（数据）；
}
回调测试（{onYes:function（data:any）{onYes1（data）；}，onNo:function（data:any）{onNo1（data）；}，onError:function（data:any）{onError1（data）；}，“一”）；
回调测试（{onYes:function（data:any）{onYes1（data）；}，onNo:function（data:any）{onNo1（data）；}，onError:function（data:any）{onError1（data）；}}，“两个”