可实现的泛型工具

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;