泛型方法-如何在 TypeScript 中使用泛型

在此代码中，您创建了两种类型，A 和 B。类型 A 是字符串文字“abc”的类型，而类型 B 是具有名为 name of type string 属性的对象的类型。

然后将这两种类型与 IsStringType 条件类型一起使用，并将结果类型存储到两个新类型 ResultA 和 ResultB 中。

如果检查 ResultA 和 ResultB 的结果类型，您会注意到 ResultA 类型设置为准确的类型 true，而 ResultB 类型设置为 false。 这是正确的，因为 A 确实扩展了字符串类型而 B 没有扩展字符串类型，因为它被设置为具有字符串类型的单个名称属性的对象的类型。

条件类型的一个有用特性是它允许您使用特殊关键字 infer 在 extends 子句中推断类型信息。 然后可以在条件的真实分支中使用这种新类型。 此功能的一种可能用法是检索任何函数类型的返回类型。

编写以下 GetReturnType 类型来说明这一点：

type GetReturnType = T extends (...args: any[]) => infer U ? U : never;

在此代码中，您将创建一个新的泛型类型，它是一个名为 GetReturnType 的条件类型。 此泛型类型接受单个类型参数 T。

在类型声明本身内部，您正在检查类型 T 是否扩展了与函数签名匹配的类型，该函数签名接受可变数量的参数（包括零），然后您推断返回 该函数的类型创建一个新类型 U，可在条件的真实分支内使用。

U 的类型将绑定到传递函数的返回值的类型。 如果传递的类型 T 不是函数，则代码将返回 never 类型。

使用您的类型和以下代码：

type GetReturnType = T extends (...args: any[]) => infer U ? U : never;
function someFunction() {  return true;}
type ReturnTypeOfSomeFunction = GetReturnType<typeof someFunction>;

在此代码中，您将创建一个名为 someFunction 的函数，该函数返回 true。 然后使用 typeof 运算符将此函数的类型传递给 GetReturnType 泛型，并将结果类型存储在 ReturnTypeOfSomeFunction 类型中。

由于 someFunction 变量的类型是函数，因此条件类型将评估条件的真实分支。 这将返回类型 U 作为结果。

类型 U 是从函数的返回类型推断出来的，在本例中是布尔值。 如果检查 ReturnTypeOfSomeFunction 的类型，您会发现它已正确设置为布尔类型。

高级条件类型用例

条件类型是 TypeScript 中可用的最灵活的功能之一，允许创建一些高级实用程序类型。

在本节中，您将通过创建一个名为 NestedOmit 的条件类型来探索这些用例之一。

此实用程序类型将能够省略对象中的字段，就像现有的 Omit 实用程序类型一样，但也允许使用点表示法省略嵌套字段。

使用新的 NestedOmit 泛型，您将能够使用以下示例中所示的类型：

type SomeType = {  a: {    b: string,    c: {      d: number;      e: string[]    },    f: number  }  g: number | string,  h: {    i: string,    j: number,  },  k: {    l: number,  }}
type Result = NestedOmit<SomeType, "a.b" | "a.c.e" | "h.i" | "k">;

此代码声明了一个名为 SomeType 的类型，它具有嵌套属性的多级结构。 使用 NestedOmit 泛型，传入类型，然后列出要省略的属性的键。

请注意如何在第二个类型参数中使用点符号来标识要省略的键。 然后将结果类型存储在 Result 中。

构造此条件类型将使用 TypeScript 中可用的许多功能，例如，模板文字类型、泛型、条件类型和映射类型。

要尝试这个泛型，首先创建一个名为 NestedOmit 的泛型类型，它接受两个类型参数：

type NestedOmit<T extends Record<string, any>, KeysToOmit extends string>

第一个类型参数称为 T，它必须是可分配给 Record 类型的类型。 这将是您要从中省略属性的对象的类型。

第二个类型参数叫做KeysToOmit，必须是字符串类型。 您将使用它来指定要从类型 T 中省略的键。

接下来，通过添加以下突出显示的代码来检查 KeysToOmit 是否可分配给 ${infer KeyPart1}.${infer KeyPart2} 类型：

type NestedOmit<T extends Record<string, any>, KeysToOmit extends string>=  KeysToOmit extends `${infer KeyPart1}.${infer KeyPart2}`

在这里，您使用模板文字字符串类型，同时，利用条件类型推断模板文字本身内部的其他两种类型。

通过推断模板文字字符串类型的两个部分，您将字符串拆分为另外两个字符串。 第一部分将分配给 KeyPart1 类型，并将包含第一个点之前的所有内容。

第二部分将分配给 KeyPart2 类型，并将包含第一个点之后的所有内容。 如果您将“a.b.c”作为 KeysToOmit 传递，则最初 KeyPart1 将设置为确切的字符串类型“a”，而 KeyPart2 将设置为“b.c”。

接下来，您将添加三元运算符来定义条件的第一个真分支：

type NestedOmit<T extends Record<string, any>, KeysToOmit extends string> =  KeysToOmit extends `${infer KeyPart1}.${infer KeyPart2}`    ?      KeyPart1 extends keyof T

这使用 KeyPart1 extends keyof T 来检查 KeyPart1 是否是给定类型 T 的有效属性。如果您确实有一个有效的键，请添加以下代码以使条件计算为两种类型之间的交集：

type NestedOmit<T extends Record<string, any>, KeysToOmit extends string> =  KeysToOmit extends `${infer KeyPart1}.${infer KeyPart2}`    ?      KeyPart1 extends keyof T      ?        Omit        & {          [NewKeys in KeyPart1]: NestedOmit        }

Omit 是一种使用 TypeScript 默认附带的 Omit 助手构建的类型。 此时，KeyPart1 不是点表示法：它将包含一个字段的确切名称，该字段包含您希望从原始类型中省略的嵌套字段。 因此，您可以安全地使用现有的实用程序类型。

您正在使用 Omit 删除 T[KeyPart1] 中的一些嵌套字段，为此，您必须重建 T[KeyPart1] 的类型。

为避免重建整个 T 类型，您使用 Omit 仅从 T 中删除 KeyPart1，同时保留其他字段。 然后，您将在下一部分的类型中重建 T[KeyPart1]。

[KeyPart1 中的新键]：NestedOmit 是一个映射类型，其中属性是可分配给 KeyPart1 的属性，这意味着您刚刚从 KeysToOmit 中提取的部分。

这是您要删除的字段的父项。 如果您通过了 a.b.c，在第一次评估您的条件时，它将是“a”中的 NewKeys。

然后将此属性的类型设置为递归调用 NestedOmit 实用程序类型的结果，但现在使用 T[NewKeys] 将此属性的类型作为第一个类型参数传递给 T，并作为第二个类型参数传递其余键以点表示法表示，在 KeyPart2 中可用。

在内部条件的 false 分支中，返回绑定到 T 的当前类型，就好像 KeyPart1 不是 T 的有效键一样：

type NestedOmit<T extends Record<string, any>, KeysToOmit extends string> =  KeysToOmit extends `${infer KeyPart1}.${infer KeyPart2}`    ?      KeyPart1 extends keyof T      ?        Omit        & {          [NewKeys in KeyPart1]: NestedOmit        }      : T

条件的这个分支意味着你试图省略一个 T 中不存在的字段。在这种情况下，没有必要再进一步了。

最后，在外部条件的 false 分支中，使用现有的 Omit 实用程序类型从 Type 中省略 KeysToOmit：

type NestedOmit<T extends Record<string, any>, KeysToOmit extends string> =  KeysToOmit extends `${infer KeyPart1}.${infer KeyPart2}`    ?      KeyPart1 extends keyof T      ?        Omit        & {          [NewKeys in KeyPart1]: NestedOmit        }      : T    : Omit;

如果条件 KeysToOmit extends `${infer KeyPart1}.${infer KeyPart2}` 为假，这意味着 KeysToOmit 没有使用点符号，因此，您可以使用现有的 Omit 实用程序类型。

现在，要使用新的 NestedOmit 条件类型，请创建一个名为 NestedObject 的新类型：

type NestedObject = {  a: {    b: {      c: number;      d: number;    };    e: number;  };  f: number;};

然后对其调用 NestedOmit 以省略 a.b.c 处可用的嵌套字段：

type Result = NestedOmit;

在第一次评估条件类型时，外部条件将为真，因为字符串文字类型“a.b.c”可分配给模板文字类型“${infer KeyPart1}.${infer KeyPart2}”。

在这种情况下，KeyPart1 将被推断为字符串文字类型“a”，而 KeyPart2 将被推断为字符串的剩余部分，在本例中为“b.c”。

现在将评估内部条件。 这将评估为真，因为此时 KeyPart1 是 T 的键。KeyPart1 现在是“a”，而 T 确实有一个属性“a”：

type NestedObject = {a: {b: {c: number;d: number;};e: number;};  f: number;};

继续评估条件，您现在位于内部 true 分支内。 这将构建一个新类型，它是其他两种类型的交集。

第一种类型是在 T 上使用 Omit 实用程序类型以省略可分配给 KeyPart1 的字段的结果，在本例中为 a 字段。 第二种类型是您通过递归调用 NestedOmit 构建的新类型。

如果您进行 NestedOmit 的下一次评估，对于第一次递归调用，交集类型现在正在构建一个类型以用作 a 字段的类型。 这将重新创建一个没有您需要省略的嵌套字段的字段。

在 NestedOmit 的最终评估中，第一个条件将返回 false，因为传递的字符串类型现在只是“c”。 发生这种情况时，您可以使用内置助手从对象中省略该字段。

这将返回 b 字段的类型，即省略了 c 的原始类型。 现在评估结束，TypeScript 返回您要使用的新类型，并省略嵌套字段。

结论

在本教程中，我们探索适用于函数、接口、类和自定义类型的泛型，以及使用了泛型来创建映射类型和条件类型。

这些都使泛型成为您在使用 TypeScript 时可以随意使用的强大工具。 正确使用它们将使您免于一遍又一遍地重复代码，并使您编写的类型更加灵活。

限时特惠：本站每日持续更新海量设计资源，一年会员只需29.9元，全站资源免费下载
站长微信：ziyuanshu688