TypeScript高级类型备忘录（附示例）

原文链接: https://dev.to/ibrahima92/advanced-typescript-types-cheat-sheet-with-examples-5414 经作者授权后翻译

文末送五本书

TypeScript 是一种类型化的语言，允许你指定变量的类型，函数参数，返回的值和对象属性。

这里是一个带有示例的高级 TypeScript 类型备忘单。

1. 交叉类型

交叉类型是将多种类型组合为一种类型的方法。这意味着你可以将给定的类型A与类型B或更多类型合并，并获得具有所有属性的单个类型。

type LeftType = {
    id: number
    left: string
}

type RightType = {
    id: number
    right: string
}

type IntersectionType = LeftType & RightType

function showType(args: IntersectionType) {
    console.log(args)
}

showType({
    id: 1, left: "test", right: "test"
})
// Output: {id: 1, left: "test", right: "test"}

IntersectionType 组合了两种类型: LeftType 和 RightType ，并使用 ＆ 符号构造交叉类型。

2. 联合类型

联合类型表示一个值可以是几种类型之一，例如某个函数希望传入 string 或者 number 类型的参数。

type UnionType = string | number

function showType(arg: UnionType) {
    console.log(arg)
}

showType("test")
// Output: test

showType(7)
// Output: 7

函数 showType 的参数是一个联合类型，它接受 string 或 number 作为参数。

3.泛型

泛型是指在定义函数、接口或类的时候，不预先指定具体的类型，而在使用的时候再指定类型的一种特性。

function showType<T>(args: T) {
    console.log(args)
}

showType("test")
// Output: "test"

showType(1)
// Output: 1

要构造泛型，需要使用尖括号并将 T 作为参数传递。在这里，我使用 T（名称自定义），然后使用不同的类型两次调用 showType 函数。

interface GenericType<T> {
    id: number
    name: T
}

function showType(args: GenericType<string>) {
    console.log(args)
}

showType({ id: 1, name: "test" })
// Output: {id: 1, name: "test"}

function showTypeTwo(args: GenericType<number>) {
    console.log(args)
}

showTypeTwo({ id: 1, name: 4 })
// Output: {id: 1, name: 4}

在这里，我们有另一个示例，该示例具有一个接口 GenericType，该接口接收泛型 T 。由于它是可重用的，因此可以首先使用字符串，然后使用数字来调用它。

interface GenericType<T, U> {
    id: T
    name: U
}

function showType(args: GenericType<number, string>) {
    console.log(args)
}

showType({ id: 1, name: "test" })
// Output: {id: 1, name: "test"}

function showTypeTwo(args: GenericType<string, string[]>) {
    console.log(args)
}

showTypeTwo({ id: "001", name: ["This", "is", "a", "Test"] })
// Output: {id: "001", name: Array["This", "is", "a", "Test"]}

泛型可以接收多个参数。在这里，我们传入两个参数：T 和 U，然后将它们用作属性的类型。也就是说，我们现在可以使用该接口并提供不同的类型作为参数。

内置类型

TypeScript 提供了方便的内置类型，可帮助轻松地操作类型。要使用它们，你需要将要转换的类型传递给 <>

Partial

Partial

Partial 允许你将 T 类型的所有属性设为可选。

interface PartialType {
    id: number
    firstName: string
    lastName: string
}

function showType(args: Partial<PartialType>) {
    console.log(args)
}

showType({ id: 1 })
// Output: {id: 1}

showType({ firstName: "John", lastName: "Doe" })
// Output: {firstName: "John", lastName: "Doe"}

如你所见，我们有一个 PartialType 接口，用作 showType() 函数接收的参数的类型。为了使属性成为可选属性，我们必须使用 Partial 关键字并将 PartialType 类型作为参数传递。也就是说，现在所有字段都变为可选。

Required

Required

与 Partial 不同，Required 所有类型为 T 的属性成为必需。

interface RequiredType {
    id: number
    firstName?: string
    lastName?: string
}

function showType(args: Required<RequiredType>) {
    console.log(args)
}

showType({ id: 1, firstName: "John", lastName: "Doe" })
// Output: { id: 1, firstName: "John", lastName: "Doe" }

showType({ id: 1 })
// Error: Type '{ id: number: }' is missing the following properties from type 'Required<RequiredType>': firstName, lastName

即使我们之前设置的是可选属性，Required 也会使所有属性成为必需。如果省略属性，TypeScript 会抛出错误。

Readonly

Readonly

Readonly 将 T 类型的所有属性变成只读属性。

interface ReadonlyType {
    id: number
    name: string
}

function showType(args: Readonly<ReadonlyType>) {
    args.id = 4
    console.log(args)
}

showType({ id: 1, name: "Doe" })
// Error: Cannot assign to 'id' because it is a read-only property.

这里，我们使用 Readonly 来使 ReadonlyType 的属性变成只读属性。如果你尝试为这些字段赋值，则会引发错误。

除此之外，还可以在属性前面使用关键字 readonly 使其只读。

interface ReadonlyType {
    readonly id: number
    name: string
}

Pick

Pick

从 T 中取出 K 中指定的属性。

interface PickType {
    id: number
    firstName: string
    lastName: string
}

function showType(args: Pick<PickType, "firstName" | "lastName">) {
    console.log(args)
}

showType({ firstName: "John", lastName: "Doe" })
// Output: {firstName: "John"}

showType({ id: 3 })
// Error: Object literal may only specify known properties, and 'id' does not exist in type 'Pick<PickType, "firstName" | "lastName">'

Pick 需要两个参数 —— T 是要从中选择元素的类型，而 K 是要选择的属性。你也可以通过使用竖线（ | ）分隔多个字段来选择多个字段。

Omit

Omit

Omit 与 Pick 相反，不是选择元素，而是从类型 T 中删除 K 属性。

interface PickType {
    id: number
    firstName: string
    lastName: string
}

function showType(args: Omit<PickType, "firstName" | "lastName">) {
    console.log(args)
}

showType({ id: 7 })
// Output: {id: 7}

showType({ firstName: "John" })
// Error: Object literal may only specify known properties, and 'firstName' does not exist in type 'Pick<PickType, "id">'

Extract

Extract

Extract 从 T 中提取所有可分配给 U 的类型。

interface FirstType {
    id: number
    firstName: string
    lastName: string
}

interface SecondType {
    id: number
    address: string
    city: string
}

type ExtractType = Extract<keyof FirstType, keyof SecondType>
// Output: "id"

在这里，我们有两种共同的属性 id。因此，通过使用 Extract 关键字，由于两个接口中都存在字段 id，因此我们可以获取它。并且，如果有有多个共同字段，Extract 将提取所有共同的属性。

Exclude

与 Extract 不同，Exclude 从 T 中排除所有可分配给 U 的类型。

interface FirstType {
    id: number
    firstName: string
    lastName: string
}

interface SecondType {
    id: number
    address: string
    city: string
}

type ExcludeType = Exclude<keyof FirstType, keyof SecondType>

// Output; "firstName" | "lastName"

如上所示，属性 firstName 和 lastName 可分配给 ExcludeType 类型，因为它们在 SecondType 中不存在。

Record

Record

Record<K,T> 构造具有给定类型 T 的一组属性 K 的类型。在将一个类型的属性映射到另一个类型的属性时，Record 非常方便。

interface EmployeeType {
    id: number
    fullname: string
    role: string
}

let employees: Record<number, EmployeeType> = {
    0: { id: 1, fullname: "John Doe", role: "Designer" },
    1: { id: 2, fullname: "Ibrahima Fall", role: "Developer" },
    2: { id: 3, fullname: "Sara Duckson", role: "Developer" },
}

// 0: { id: 1, fullname: "John Doe", role: "Designer" },
// 1: { id: 2, fullname: "Ibrahima Fall", role: "Developer" },
// 2: { id: 3, fullname: "Sara Duckson", role: "Developer" }

Record 的工作方式相对简单。在这里，它期望数字作为类型，属性值的类型是 EmployeeType ，因此具有 id，fullName 和 role 字段的对象。

NonNullable

NonNullable

NonNullable 从类型T中删除 null 和 undefined。

type NonNullableType = string | number | null | undefined

function showType(args: NonNullable<NonNullableType>) {
    console.log(args)
}

showType("test")
// Output: "test"

showType(1)
// Output: 1

showType(null)
// Error: Argument of type 'null' is not assignable to parameter of type 'string | number'.

showType(undefined)
// Error: Argument of type 'undefined' is not assignable to parameter of type 'string | number'.

在这里，我们将类型 NonNullableType 作为参数传递给 NonNullable ，NonNullable 将该类型中排除 null 和 undefined 来构造新类型。也就是说，如果传递可为空的值，TypeScript 将报错。

顺便说一句，如果将 --strictNullChecks 标志添加到 tsconfig 文件，TypeScript 将应用非空性规则。

Mapped types

映射类型允许你采用现有模型并将其每个属性转换为新类型。

type StringMap<T> = {
    [P in keyof T]: string
}

function showType(arg: StringMap<{ id: number; name: string }>) {
    console.log(arg)
}

showType({ id: 1, name: "Test" })
// Error: Type 'number' is not assignable to type 'string'.

showType({ id: "testId", name: "This is a Test" })
// Output: {id: "testId", name: "This is a Test"}

StringMap<> 会将传入的任何类型转换为字符串。就是说，如果我们在函数 showType() 中使用它，则接收到的参数必须是字符串，否则，TypeScript 将报错。

类型保护

类型保护使你可以使用运算符检查变量或对象的类型。

typeof

function showType(x: number | string) {
    if (typeof x === "number") {
        return `The result is ${x + x}`
    }
    throw new Error(`This operation can't be done on a ${typeof x}`)
}

showType("I'm not a number")
// Error: This operation can't be done on a string

showType(7)
// Output: The result is 14

我们有一个普通的 JavaScript 条件块，使用 typeof 来检查入参的类型。

instanceof

instanceof 类型保护是通过构造函数来细化类型的一种方式。

class Foo {
    bar() {
        return "Hello World"
    }
}

class Bar {
    baz = "123"
}

function showType(arg: Foo | Bar) {
    if (arg instanceof Foo) {
        console.log(arg.bar())
        return arg.bar()
    }

    throw new Error("The type is not supported")
}

showType(new Foo())
// Output: Hello World

showType(new Bar())
// Error: The type is not supported

in

interface FirstType {
    x: number
}
interface SecondType {
    y: string
}

function showType(arg: FirstType | SecondType) {
    if ("x" in arg) {
        console.log(`The property ${arg.x} exists`)
        return `The property ${arg.x} exists`
    }
    throw new Error("This type is not expected")
}

showType({ x: 7 })
// Output: The property 7 exists

showType({ y: "ccc" })
// Error: This type is not expected

条件类型

它测试两种类型，并根据该测试的结果选择其中一种。

type NonNullable<T> = T extends null | undefined ? never : T

NonNullable 检查类型是否为 null 或者 undefined，并根据检查结果进行处理。