什么是工具类型
用 JavaScript 编写中大型程序是离不开 lodash 工具的，而用 TypeScript 编程同样离不开工具类型的帮助，工具类型就是类型版的 lodash 。简单的来说，就是把已有的类型经过类型转换构造一个新的类型。工具类型本身也是类型，得益于泛型的帮助，使其能够对类型进行抽象的处理。工具类型主要目的是简化类型编程的过程，提高生产力。
使用工具类型的好处
先来看看一个场景，体会下工具类型带来什么好处。
// 一个用户接口
interface User {
name: string
avatar: string
country：string
friend：{
name: string
sex: string
}
}
现在业务要求 User 接口里的成员都变为可选，你会怎么做？再定义一个接口，为成员都加上可选修饰符吗？这种方法确实可行，但接口里有几十个成员呢？此时，工具类型就可以派上用场。
type Partial<T> = {[K in keyof T]?: T[K]}
type PartialUser = Partial<User>
// 此时PartialUser等同于
type PartialUser = {
name?: string | undefined;
avatar?: string | undefined;
country?: string | undefined;
friend?: {
name: string;
sex: string;
} | undefined;
}
通过工具类型的处理，我们得到一个新的类型。即使成员有成千上百个，我们也只需要一行代码。由于 friend 成员是对象，上面的 Partial 处理只对第一层添加可选修饰符，假如需要将对象成员内的成员也添加可选修饰符，可以使用 Partial 递归来解决。
type partial<T> = {
[K in keyof T]?: T[K] extends object ? partial<T[K]> : T[K]
}
如果你是第一次看到以上的写法，可能会很懵逼，不知道发生了什么操作。不慌，且往下看，或许当你看完这篇文章再回过头来看时，会发现原来是这么一回事。
关键字
TypeScript 中的一些关键字对于编写工具类型必不可缺
keyof
语法： keyof T 。返回联合类型，为 T 的所有 key
interface User{
name: string
age: number
}
type Man = {
name:string,
height: 180
}
type ManKeys = keyof Man // "name" | "height"
type UserKeys = keyof User // "name" | "age"
typeof
语法： typeof T 。返回 T 的成员的类型
let arr = ['apple', 'banana', 100]
let man = {
name: 'Jeo',
age: 20,
height: 180
}
type Arr = typeof arr // (string | number)[]
type Man = typeof man // {name: string; age: number; height: number;}
infer
相比上面两个关键字， infer 的使用可能会有点难理解。在有条件类型的 extends 子语句中，允许出现 infer 声明，它会引入一个待推断的类型变量。这个推断的类型变量可以在有条件类型的 true 分支中被引用。
简单来说，它可以把类型处理过程的某个部分抽离出来当做类型变量。以下例子需要结合高级类型，如果不能理解，可以选择跳转这部分，把高级类型看完后再回来。
下面代码会提取函数类型的返回值类型：
type ReturnType<T> = T extends (...args: any[]) => infer R ? R : any;
(...args: any[]) => infer R 和 Function 类型的作用是差不多的，这样写只是为了能够在过程中拿到函数的返回值类型。 infer 在这里相当于把返回值类型声明成一个类型变量，提供给后面的过程使用。
有条件类型可以嵌套来构成一系列的匹配模式，按顺序进行求值：
type Unpacked<T> =
T extends (infer U)[] ? U :
T extends (...args: any[]) => infer U ? U :
T extends Promise<infer U> ? U :
T;
type T0 = Unpacked<string>; // string
type T1 = Unpacked<string[]>; // string
type T2 = Unpacked<() => string>; // string
type T3 = Unpacked<Promise<string>>; // string
type T4 = Unpacked<Promise<string>[]>; // Promise<string>
type T5 = Unpacked<Unpacked<Promise<string>[]>>; // string
高级类型
交叉类型
语法： A & B ，交叉类型可以把多个类型合并成一个新类型，新类型将拥有所有类型的成员。
interface Shape {
size: string
color: string
}
interface Brand {
name: string
price: number
}
let clothes: Shape&Brand = {
name: 'Uniqlo',
color: 'blue',
size: 'XL',
price: 200
}
联合类型
语法： typeA | typeB ，联合类型是包含多种类型的类型，被绑定联合类型的成员只需满足其中一种类型。
function pushItem(item:string|number){
let array:Array<string|number> = ['apple','banana','cherry']
array.push(item)
}
pushItem(10) // ok
pushItem('durian') // ok
通常，删除用户信息需要提供 id ，创建用户则不需要 id 。这种类型应该如何定义？如果选择为 id 字段提供添加可选修饰符的话，那就太不明智了。因为在删除用户时，即使不填写 id 属性也不会报错，这不是我们想要的结果。
可辨识联合类型能帮助我们解决这个问题：
type UserAction = {
action: 'create'
}|{
id:number
action: 'delete'
}
let userAction:UserAction = {
id: 1,
action: 'delete'
}
字面量类型
字⾯量类型主要分为 真值字⾯量类型，数字字⾯量类型，枚举字⾯量类型，⼤整数字⾯量类型、字符串字⾯量类型。
const a: 2333 = 2333 // ok
const b: 0b10 = 2 // ok
const c: 0x514 = 0x514 // ok
const d: 'apple' = 'apple' // ok
const e: true = true // ok
const f: 'apple' = 'banana' // 不能将类型“"banana"”分配给类型“"apple"”
下面以字符串字面量类型作为例子:
字符串字面量类型允许指定的字符串作为类型。如果使用 JavaScript 的模式中看下面的例子，会把 level 当成一个值。但在 TypeScript 中，千万不要用这种思维去看待， level 表示的就是一个字符串 coder 的类型，被绑定这个类型的变量，它的值只能是 coder 。
type Level = 'coder'
let level:Level = 'coder' // ok
let level2:Level = 'programmer' // 不能将类型“"programmer"”分配给类型“"coder"”
字符串和联合类型搭配，可以实现类似枚举类型的字符串
type Level = 'coder' | 'leader' | 'boss'
function getWork(level: Level){
if(level === 'coder'){
console.log('打代码、摸鱼')
}else if(level === 'leader'){
console.log('造轮子、架构')
}else if(level === 'boss'){
console.log('喝茶、谈生意')
}
}
getWork('coder')
getWork('user') // 类型“"user"”的参数不能赋给类型“Level”的参数
索引类型
语法： T[K] ，使用索引类型，编译器就能够检查使用动态属性名的代码。在 JavaScript 中，对象可以用属性名获取值，而在 TypeScript 中，这一切被抽象化，变成通过索引获取类型。就像 person[name] 被抽象成类型 Person[name] ，在以下例子中代表的就是 string 类型。
interface Person {
name: string;
age: number;
}
let person: Person = {
name: 'Jeo',
age: 20
}
let name = person['name'] // 'Jeo'
type str = Person['name'] // string
我们可以在普通的上下文里使用 T[K] ，只要确保类型变量 K 为 T 的索引即可
function getProperty<T, K extends keyof T>(o: T, name: K): T[K] {
return o[name]; // o[name] is of type T[K]
}
getProperty 里的 o: T 和 name: K ，意味着 o[name]: T[K]
let name: string = getProperty(person, 'name');
let age: number = getProperty(person, 'age');
let unknown = getProperty(person, 'unknown'); // 类型“"unknown"”的参数不能赋给类型“"name" | "age"”的参数
K 不仅可以传成员，成员的字符串联合类型也是有效的
type Union = Person[keyof Person] // "string" | "number"
映射类型
语法： [K in Keys] 。TypeScript 提供了从旧类型中创建新类型的一种方式 。在映射类型里，新类型以相同的形式去转换旧类型里每个属性。根据 Keys 来创建类型， Keys 有效值为 string | number | symbol 或 联合类型。
type Keys = 'name'|10
type User = {
[K in Keys]: string
}
该语法可以理解为内部使用了循环
- K: 依次绑定到每个属性，相当于 Keys 的项
- Keys: 包含要迭代的属性名的集合
因此以上的例子等同于：
type User = {
name: string;
10: string;
}
需要注意的是这个语法描述的是类型而非成员。若想添加额外的成员，需使用交叉类型：
// 这样使用
type ReadonlyWithNewMember<T> = {
readonly [P in keyof T]: T[P];
} & { newMember: boolean }
// 不要这样使用
// 这会报错！
type ReadonlyWithNewMember<T> = {
readonly [P in keyof T]: T[P];
newMember: boolean;
}
在真正应用中，映射类型结合索引访问类型是一个很好的搭配。因为转换过程会基于一些已存在的类型，且按照一定的方式转换字段。你可以把这过程理解为 JavaScript 中数组的 map 方法，在原本的基础上扩展元素（ TypeScript 中指类型），当然这种理解过程可能有点粗糙。
文章开头的 Partial 工具类型正是使用这种搭配，为原有的类型添加可选修饰符。
条件类型
语法： T extends U ? X : Y ，若 T 能够赋值给 U ，那么类型是 X ，否则为 Y 。条件类型以条件表达式推断类型关系，选择其中一个分支。相对上面的类型，条件类型很好理解，类似 JavaScript 中的三目运算符。
再来看看文章开头递归的操作，你就会发现能看懂这段处理过程。过程：使用映射类型遍历，判断 T[K] 属于 object 类型，则把 T[K] 传入 partial 递归，否则返回类型 T[K] 。
type partial<T> = {
[K in keyof T]?: T[K] extends object ? partial<T[K]> : T[K]
}
小结
关于一些常用的高级类型相信大家都了解得差不多，下面将应用这些类型来编写一个工具类型。
该工具类型实现的功能为筛选出两个 interface 的公共成员：
interface PersonA{
name: string
age: number
boyfriend: string
car: {
type: 'Benz'
}
}
interface PersonB{
name: string
age: string
girlfriend: string
car: {
type: 'bicycle'
}
}
type Filter<T,U> = T extends U ? T : never
type Common<A, B> = {
[K in Filter<keyof A, keyof B>]: A[K] extends B[K] ? A[K] : A[K]|B[K]
}
通过 Filter 筛选出公共的成员联合类型 "name"|"age" 作为映射类型的集合，公共部分可能会存在类型不同的情况，因此要为成员保留两者的类型。
type CommonMember = Common<PersonA, PersonB>
// 等同于
type CommonMember = {
name: string;
age: string | number;
car: {
type: "Benz";
} | {
type: "bicycle";
};
}
内置工具类型
为了满足常见的类型转换需求， TypeScript 也提供一些内置工具类型，这些类型是全局可见的。
Partial
构造类型 T ，并将它所有的属性设置为可选的。它的返回类型表示输入类型的所有子类型。
interface Todo {
title: string;
description: string;
}
function updateTodo(todo: Todo, fieldsToUpdate: Partial<Todo>) {
return { ...todo, ...fieldsToUpdate };
}
const todo1 = {
title: 'organize desk',
description: 'clear clutter',
};
const todo2 = updateTodo(todo1, {
description: 'throw out trash',
});
Readonly
构造类型T，并将它所有的属性设置为readonly，也就是说构造出的类型的属性不能被再次赋值。
interface Todo {
title: string;
}
const todo: Readonly<Todo> = {
title: 'Delete inactive users',
};
todo.title = 'Hello'; // Error: cannot reassign a readonly property
Record<K, T>
构造一个类型，其属性名的类型为K，属性值的类型为T。这个工具可用来将某个类型的属性映射到另一个类型上。
interface PageInfo {
title: string;
}
type Page = 'home' | 'about' | 'contact';
const x: Record<Page, PageInfo> = {
about: { title: 'about' },
contact: { title: 'contact' },
home: { title: 'home' },
};
Pick<T, K>
从类型T中挑选部分属性K来构造类型。
interface Todo {
title: string;
description: string;
completed: boolean;
}
type TodoPreview = Pick<Todo, 'title' | 'completed'>;
const todo: TodoPreview = {
title: 'Clean room',
completed: false,
};
Omit<T, K>
从类型T中剔除部分属性K来构造类型，与Pick相反。
interface Todo {
title: string;
description: string;
completed: boolean;
}
type TodoPreview = Omit<Todo, 'title' | 'completed'>;
const todo: TodoPreview = {
description: 'I am description'
};
Exclude<T, U>
从类型T中剔除所有可以赋值给U的属性，然后构造一个类型。
type T0 = Exclude<"a" | "b" | "c", "a">; // "b" | "c"
type T1 = Exclude<"a" | "b" | "c", "a" | "b">; // "c"
type T2 = Exclude<string | number | (() => void), Function>; // string | number
Extract<T, U>
从类型T中提取所有可以赋值给U的类型，然后构造一个类型。
type T0 = Extract<"a" | "b" | "c", "a" | "f">; // "a"
type T1 = Extract<string | number | (() => void), Function>; // () => void
NonNullable
从类型T中剔除null和undefined，然后构造一个类型。
type T0 = NonNullable<string | number | undefined>; // string | number
type T1 = NonNullable<string[] | null | undefined>; // string[]
ReturnType
由函数类型T的返回值类型构造一个类型。
type T0 = ReturnType<() => string>; // string
type T1 = ReturnType<(s: string) => void>; // void
type T2 = ReturnType<(<T>() => T)>; // {}
type T3 = ReturnType<(<T extends U, U extends number[]>() => T)>; // number[]
type T5 = ReturnType<any>; // any
type T6 = ReturnType<never>; // any
type T7 = ReturnType<string>; // Error
type T8 = ReturnType<Function>; // Error
InstanceType
由构造函数类型T的实例类型构造一个类型。
class C {
x = 0;
y = 0;
}
type T0 = InstanceType<typeof C>; // C
type T1 = InstanceType<any>; // any
type T2 = InstanceType<never>; // any
type T3 = InstanceType<string>; // Error
type T4 = InstanceType<Function>; // Error
let t0:T0 = {
x: 10,
y: 2
}
Required
构造一个类型，使类型T的所有属性为required。
interface Props {
a?: number;
b?: string;
};
const obj: Props = { a: 5 }; // OK
const obj2: Required<Props> = { a: 5 }; // Error: property 'b' missing
写在最后
除了介绍编写工具类型所需要具备的一些知识点，以及 TypeScript 内置的工具类型。更重要的是抽象思维能力，不难发现上面的例子大部分没有具体的值运算，都是使用类型在编程。想要理解这些知识，必须要进入到抽象逻辑里思考。还有高级类型的搭配和类型转换的处理，也要通过大量的实践才能玩好。说实话，自己学习这些知识时，真正感受到 TypeScript 的深不可测，也了解到自身的不足之处。突然想起在某篇文章的一句话：技术是无止尽的，接触的越多，越能感到自己的渺小。