头图

泛型工具及实现

tonychen
English

可实现的泛型工具

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.

PickExclude 其实都是非常基础的工具泛型,很多时候你如果直接用 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;
阅读 151

随缘发文~有疑问可以文章下留言~

1.2k 声望
267 粉丝
0 条评论
你知道吗?

随缘发文~有疑问可以文章下留言~

1.2k 声望
267 粉丝
宣传栏