在typescript中写入函数类型：胖箭头和对象文字类型

我正在学习Typescript，我阅读了两种编写函数类型的方法：使用胖箭头或对象文字

例如：

let myAdd1: (x: number, y: number) => number =
    function(x: number, y: number): number {return x + y; };

let myAdd2: { (x: number, y: number): number } =
    function(x: number, y: number): number {return x + y; };

使用其中一个而不是另一个的原因是什么

---

谢谢您的回答。

第一个示例是普通类型的函数声明和赋值。第二个示例使用函数重载速记

假设我们有一些正常的函数重载：

function myMultiAdd(x: number, y: number): number;
function myMultiAdd(x: number, y: number, z?: number): number {
    return x + y + (z ? z : 0);
}

myMultiAdd（1,2）

和

myMultiAdd（1,2,3）

都可以工作。当有许多函数重载时，使用此模式很不方便，因为我们会一次又一次重复相同的名称，因此typescript有一个简短的函数重载语法，如下所示：

let myMultiAdd: {
    (x: number, y: number): number,
    (x: number, y: number, z: number): number
} = function (x: number, y: number, z?: number): number {
    return x + y + (z ? z : 0);
}

---

因此，如果您不想使用函数重载，那么您应该始终使用第一个示例来键入函数。

第一个示例是普通类型的函数声明和赋值。第二个示例使用函数重载速记

假设我们有一些正常的函数重载：

function myMultiAdd(x: number, y: number): number;
function myMultiAdd(x: number, y: number, z?: number): number {
    return x + y + (z ? z : 0);
}

myMultiAdd（1,2）

和

myMultiAdd（1,2,3）

都可以工作。当有许多函数重载时，使用此模式很不方便，因为我们会一次又一次重复相同的名称，因此typescript有一个简短的函数重载语法，如下所示：

let myMultiAdd: {
    (x: number, y: number): number,
    (x: number, y: number, z: number): number
} = function (x: number, y: number, z?: number): number {
    return x + y + (z ? z : 0);
}

---

因此，如果您不想使用函数重载，那么您应该始终使用第一个示例来键入函数。

这些是以不同方式编写的相同类型：

let myAdd1: (x: number, y: number) => number;
type Func = typeof myAdd1;
// type Func = (x: number, y: number) => number
let myAdd2: { (x: number, y: number): number };
type Callable = typeof myAdd2;
// type Callable = (x: number, y: number) => number

您可以看到编译器认为

Func

和

Callable

都属于

（x:number，y:number）=>number

类型。因为它们是一样的，所以选择其中一个而不是另一个的原因很可能是主观的和基于观点的

---

但是，如果开始向函数添加属性，则对象表示法可能更易于表示：

let func1: ((x: string) => string) & { color: string } =
  Object.assign((z: string) => z.toUpperCase(), { color: "red" });
type FuncWithProp = typeof func1;
// type FuncWithProp = ((x: string) => string) & { color: string; }
let func2: { (x: string): string; color: string } = 
  Object.assign((z: string) => z.toLowerCase(), { color: "green" });
type CallableWithProp = typeof func2;
// type CallableWithProp = { (x: string): string; color: string }

类型

FuncWithProp

和

CallableWithProp

不再被认为是相同的，但它们可以相互分配（这意味着编译器看到每个

扩展了另一个
）：

类型MutuallyExtends=void；
类型FuncVsCallableWithprops=MutuallyExtends；//可以

因此，原则上您也可以使用任何一种，但是
FuncWithProp
是一种对象类型，而
CallableWithProp
是一种单一对象类型，在某些边缘情况下可能表现更好


好吧，希望这会有帮助；祝你好运

这些是以不同方式书写的相同类型：

let myAdd1: (x: number, y: number) => number;
type Func = typeof myAdd1;
// type Func = (x: number, y: number) => number
let myAdd2: { (x: number, y: number): number };
type Callable = typeof myAdd2;
// type Callable = (x: number, y: number) => number

您可以看到编译器认为
Func
和
Callable
都属于
（x:number，y:number）=>number
类型。因为它们是一样的，所以选择其中一个而不是另一个的原因很可能是主观的和基于观点的


但是，如果开始向函数添加属性，则对象表示法可能更易于表示：

let func1: ((x: string) => string) & { color: string } =
  Object.assign((z: string) => z.toUpperCase(), { color: "red" });
type FuncWithProp = typeof func1;
// type FuncWithProp = ((x: string) => string) & { color: string; }
let func2: { (x: string): string; color: string } = 
  Object.assign((z: string) => z.toLowerCase(), { color: "green" });
type CallableWithProp = typeof func2;
// type CallableWithProp = { (x: string): string; color: string }

类型
FuncWithProp
和
CallableWithProp
不再被认为是相同的，但它们可以相互分配（这意味着编译器看到每个
扩展了另一个
）：

类型MutuallyExtends=void；
类型FuncVsCallableWithprops=MutuallyExtends；//可以

因此，原则上您也可以使用任何一种，但是
FuncWithProp
是一种对象类型，而
CallableWithProp
是一种单一对象类型，在某些边缘情况下可能表现更好


好吧，希望这会有帮助；祝你好运

非常感谢。这对我有帮助。非常感谢。这对我有帮助。非常感谢。很抱歉，我不能接受两个答案。不过，你的回答很有趣。非常感谢。很抱歉，我不能接受两个答案。然而，你的回答很有趣。