typescript 常用工具类型

Partial

可选，但不允许添加接口中没有的属性

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

interface IUser {
  name: string
  age: number
}
//经过 Partial 类型转化后得到
type optional = Partial<IUser>
// optional的结果如下
type optional = {
    name?: string | undefined;
    age?: number | undefined;
}

Required

必选，将属性全部变成必选

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

Readonly

只读，将某个类型变为只读属性，不能被重新赋值

  type Readonly<T> = { readonly [P in keyof T]: T[P];};

interface Person {
    readonly id: number;
    name: string;
    age?: number;
}
let tom: Person = {
    id: 1,
    name: 'Tom'
};
tom.id = 2;      //  无法分配给“id”，因为它是常量或只读属性

NonNullable

过滤null和undefined

type NonNullable<T> = T extends null | undefined ? never : T;

type T0 = NonNullable<string | number | undefined>; // string | number
type T1 = NonNullable<string[] | null | undefined>; // string[]

Exclude

删除联合类型中的某些类型构造一个新的类型

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

// 排除掉 "name"
type UserInfoA = Exclude<"name" | "age", "name">;
// 等价于
type UserInfoB = "age";

Extract

提取一个联合类型中的某些类型构造新的类型

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

type T1 = "name" | "age" | "id"; 
type T2 = "name" | "age"; 
type UserInfoT = Extract<T1, T2>; // Extract<"name" | "age" | "id", "name" | "age">
// 等价于 
type UserInfoA = "name" | "age";

Pick

部分选择，从已声明的类型中抽取一个子类型

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

interface User {
    id: number;
    name: string;
    age: number;
}
 
type PickUser = Pick<User, "id" | "name">;
 
// 等价于
type PickUser = {
    id: number;
    name: string;
};
 
let user: PickUser = {
    id: 1,
    name: 'tom'
};

Omit

忽略，从已声明类型中忽略掉不需要的类型

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

// 表示忽略掉User接口中的age属性
type OmitUser = Omit<User, "age">;
// 等价于
type OmitUser = {
  id: number;
  name: string;
};
 
let user: OmitUser = {
    id: 1,
    name: 'tom'
};

Record

将一个类型的属性映射到另一个类型的属性，构造字面量对象

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

interface User {
    id: number
    name: string
    age: number
}

let Users: Record<number, User> = {
    0: {id: 1,name: 'name1', age: 1},
    1: {id: 2,name: 'name2', age: 2},
    2: {id: 3,name: 'name3', age: 3}
}

Record第一个参数可接收一组key

interface UserInfo {
    name:string;
    age:number;
}
type group = 'name' | 'age'

// 注意：Record 第二个参数只能接受一个类型。所以这里用 any，或者联合类型。
type UserInfoT = Record<group, string | number>
type UserInfoT = {
     name:string | number;
     age:string | number;
 }
 
type UserInfoT1 = Record<group | 'id', UserInfo>
type UserInfoT1 = {
     name:{name: 'name1', age: 1};
     age:{name: 'name2', age: 2};
     id:{name: 'name3', age: 3};
 }