Partial 将一个类型的属性全部变为可选
/**
* Make all properties in T optional
*/
type Partial<T> = {
[P in keyof T]?: T[P];
};
keyof遍历所有泛型T组成一个新的类型，然后将新类型的所有属性变为可选?
使用方法：
interface UserInfo {
name: string;
age: number;
gender: number;
};
// 将UserInfo中的属性变为可选
const userInfo: Partial<UserInfo> = {
name: '张三'
};
Required 将一个类型的属性全部变为必选
/**
* Make all properties in T required
*/
type Required<T> = {
[P in keyof T]-?: T[P];
};
与Partial相反，在遍历所有泛型T后，将所得到的新类型的所有属性变为必选-?属性
使用方法：
interface UserInfo {
id?: string | number;
name: string;
age: number;
};
// 将UserInfo中的属性变为必选
const userInfo: Required<UserInfo> = {
id: '001', // 必选
name: '张三',
age: 20
};
Readonly 将一个类型的属性全部变为只读
/**
* Make all properties in T readonly
*/
type Readonly<T> = {
readonly [P in keyof T]: T[P];
};
遍历泛型T中的所有属性并将其转化为只读
使用方法：
interface UserInfo {
id: string | number;
name: string;
age: number;
};
// 将UserInfo中的属性变为只读
const userInfo: Readonly<UserInfo> = {
id: '001',
name: '张三',
age: 20
};
// error: 无法分配到 "name" ，因为它是只读属性。
userInfo.name = 'Lily';
Pick 从类型T中将所有的K取出来生成一个新的类型
/**
* From T, pick a set of properties whose keys are in the union K
*/
type Pick<T, K extends keyof T> = {
[P in K]: T[P];
};
从一个集合中挑选出指定的属性作为一个新的联合类型
使用方法：
interface UserInfo = {
id: string | number;
name: string;
age: number;
};
const userInfo: Pick<UserInfo, 'name'> = {
name: '张三',
age: 20
};
// 张三
console.log(userInfo.name);
// error: 类型“Pick<UserInfo, "name">”上不存在属性“age”
console.log(userInfo.age);
Record 生成一个属性为K类型为T的类型集合
/**
* Construct a type with a set of properties K of type T
*/
type Record<K extends keyof any, T> = {
[P in K]: T;
};
使用方法：
interface UserInfo {
id: string | number;
name: string;
age: number;
}
const userInfo: Record<string, T> = {
person: {
id: '001',
name: '张三',
age: 20
}
};
Exclude 排除联合类型T中包含U的属性（差集：T - (T ∩ U)）
/**
* Exclude from T those types that are assignable to U
*/
type Exclude<T, U> = T extends U ? never : T;
排除两个联合类型中包含的公共部分
使用方法：
type Cat1 = 'Kitty' | 2;
type Cat2 = 'Lily' | 2;
type Cat = Exclude<Cat1, Cat2>;
// 等同于
type Cat = 'Kitty';
Extract 提取联合类型T中包含U的属性（交集：T ∩ U）
/**
* Extract from T those types that are assignable to U
*/
type Extract<T, U> = T extends U ? T : never;
与Exclude刚好相反，提取两个联合类型中的公共部分
使用方法：
type Cat1 = 'Kitty' | 2;
type Cat2 = 'Lily' | 2;
type Cat = Extract<Cat1, Cat2>;
// 等同于
type Cat = 2;
Omit 用来忽略T中包含的K属性构造一个新的对象
/**
* Construct a type with the properties of T except for those in type K.
*/
type Omit<T, K extends keyof any> = Pick<T, Exclude<keyof T, K>>;
使用方法：
interface UserInfo = {
id: string | number;
name: string;
age: number;
};
// userInfo中只包含 name 和 age 属性
const userInfo: Omit<UserInfo, 'id'> = {
name: '张三',
age: 20
};
NonNullable 从类型T中排除null和undefined构造一个新的对象
/**
* Exclude null and undefined from T
*/
type NonNullable<T> = T extends null | undefined ? never : T;
使用方法：
type UserInfo = '张三' | undefined | null;
// userInfo中包含的可选的值为 '张三'
const userInfo: NonNullable<UserInfo> = '张三';
ReturnType 获取函数类型的返回类型
/**
* Obtain the return type of a function type
*/
type ReturnType<T extends (...args: any) => any> = T extends (...args: any) => infer R ? R : any;
使用方法：
const userInfo: ReturnType<() => string> = 'string'; // string
const userInfo: ReturnType<() => number> = 1; // number
Uppercase 将字符串文字类型转换为大写
/**
* Convert string literal type to uppercase
*/
type Uppercase<S extends string> = intrinsic;
使用方法：
type Message = 'Hello, World~';
type Msg = Uppercase<Message>;
// 等同于
type Msg = 'HELLO, WORLD~';
Lowercase 将字符串文字类型转换为小写
/**
* Convert string literal type to lowercase
*/
type Lowercase<S extends string> = intrinsic;
使用方法：
type Message = 'Hello, World~';
type Msg = Lowercase<Message>;
// 等同于
type Msg = 'hello, world~';
Capitalize 将字符串文字类型首字母转为大写
/**
* Convert first character of string literal type to uppercase
*/
type Capitalize<S extends string> = intrinsic;
使用方法：
type Message = 'hello, world~';
type Msg = Capitalize<Message>;
// 等同于
type Msg = 'Hello, world~';
Uncapitalize 将字符串文字类型首字母转为小写
/**
* Convert first character of string literal type to lowercase
*/
type Uncapitalize<S extends string> = intrinsic;
使用方法：
type Message = 'Hello, World~';
type Msg = Uncapitalize<Message>;
// 等同于
type Msg = 'hello, World~';
ThisType
/**
* Marker for contextual 'this' type
*/
interface ThisType<T> { }
参考文档 typescript/lib/lib.es5.d.ts
