泛型工具及实现

可实现的泛型工具

Pick

定义

From T, pick a set of properties whose keys are in the union K

大意：从 T 中挑出一些属性集合 K 来组成新的类型，举个例子：

type Parent = {
    name: string;
    age: number;
}
// 现在 Child 就有了 age 这个属性
type Child = Pick<Parent, 'age'>

源码

type Pick<T, K extends keyof T> = {
    [P in K]: T[P];
};

Exclude

定义

Exclude from T those types that are assignable to U

大意：从 T 中剔除一些属性，举个例子：

type GirlFriend = 'girl friend'

type Parent = {
    name: string;
    age: number;
    girlFriend: GirlFriend;
}

type Child = Exclude<keyof Parent, 'girlFriend'>

⚠注意这里 Child 相当于 type Child = 'name' | 'age'

源码

type Exclude<T, U> = T extends U ? never : T;

Omit

定义

Construct a type with the properties of T except for those in type K.

Pick 和 Exclude 其实都是非常基础的工具泛型，很多时候你如果直接用 Pick 或者 Exclude 效果还不如直接写来得直接。而 Omit 就基于这两个基础之上做的一个更抽象的封装，它允许你从一个对象中剔除若干个属性，剩下的就是你需要的新类型。下面是一个例子：

type GirlFriend = 'girl friend'

type Parent = {
    name: string;
    age: number;
    girlFriend: GirlFriend;
}

type Child = Omit<Parent, 'girlFriend'>

// 等价于
// type Child = {
//    name: string;
//    age: number;
// }

源码

type Omit<T, K extends keyof any> = Pick<T, Exclude<keyof T, K>>;

Partial

定义

Make all properties in T optional

大意：令所有的 T 的属性都变成可选属性，举个例子👇

type Root = {
    name: string;
    age: number;
}

type Test = Partial<Root>
// 等价于
// type Test = {
//   name?: string;
//   age?: number;
// }

这样，新的类型中所有的属性都会变成可选属性（可有可无的赶脚

源码

type Partial<T> = {
    [P in keyof T]?: T[P];
};

Required

定义

Make all properties in T required

大意：和 Partial 刚好相反，Required 会使所有属性都变成必选属性。

源码

type Required<T> = {
    [P in keyof T]-?: T[P];
};

ReturnType

定义

Obtain the return type of a function type

大意：返回传入的值的类型，如果它是函数，就返回它的返回值的类型。

如何使用呢？比如说我要获取函数 foo 的返回值类型👇

function foo(type): boolean {
  return type === 0
}

那么我可以利用 ReturnType 来创建一个针对 foo 的类型，比如说👇

type FooType = ReturnType<typeof foo>

⚠️注意：这里之所以使用 typeof ，是为了获取 foo 的函数签名，这里等价于 (type: any) => boolean

源码

type ReturnType<T> = T extends (...args: any[]) => infer R ? R : T

内置的泛型工具

Uppercase

定义

Convert string literal type to uppercase

大意：将所有字符转为大写形式，比如说我可以这样使用👇

type Test = 'a' | 'b' | 'c'
type UpTest = Uppercase<Test>
// 等价于
// type UpTest = Uppercase<'A' | 'B' | 'C'>

源码

type Uppercase<S extends string> = intrinsic;

Lowercase

定义

Convert string literal type to lowercase*

大意：将所有字符转为小写，举个例子👇

type Test = 'A' | 'B' | 'C'
type LowTest = Lowercase<Test>
// 等价于 type Lowtest = 'a' | 'b' | 'c'

源码

type Lowercase<S extends string> = intrinsic;

Capitalize

定义

Convert first character of string literal type to uppercase

大意：将字符串的首个字符转为大写，举个例子👇

type Test = 'apple'
type CapTest = Capitalize<Test>
// 等价于 type CapTest = 'Apple'

源码

type Capitalize<S extends string> = intrinsic;

Uncapitalize

定义

Convert first character of string literal type to lowercase

大意：将字符串的首个字符转为小写，举个例子👇

type Test = 'Apple'
type CapTest = Uncapitalize<Test>
// 等价于 type CapTest = 'apple'

源码

type Uncapitalize<S extends string> = intrinsic;