ts 高阶类型(映射类型、条件类型)

高阶类型

映射类型

Pick<T, K> 挑选映射

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

Pick<T, K> 挑选 T 类型中字符串字面量 K 属性后构成的新类型

interface User {
  name: string;
  age: number;
  height: number;
  weight: number;
}

type PickUser = Pick<User, 'name' | 'height'>
// 等同于:
type PickUser = {
  name: string;
  height?: number;
}

Partial<T> 可选映射

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

Partial<T> 将类型 T 中所有属性转化为可选属性

interface User {
  name: string;
  age?: number;
  height?: number;
  weight: number;
}

type PartialUser = Partial<User>
// 等同于:
type PartialUser = {
  name?: string;
  age?: number;
  height?: number;
  weight?: number;
}

Required<T> 必选映射

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

Required<T> 将类型 T 中所有属性转化为必须属性

interface User {
  name: string;
  age?: number;
  height?: number;
  weight: number;
}

type RequiredlUser = Required<User>
// 等同于:
type RequiredUser = {
  name: string;
  age: number;
  height: number;
  weight: number;
}

Readonly<T> 只读映射

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

Readonly<T> 将类型 T 中所有属性转化为只读属性

interface User {
  name: string;
  age?: number;
  height?: number;
  weight: number;
}

type ReadonlylUser = Readonly<User>
// 等同于:
type ReadonlyUser = {
  readonly name: string;
  readonly age?: number;
  readonly height?: number;
  readonly weight: number;
}

Record<T> 属性映射

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

Record<T> 将字符串字面量类型 K 中所有字串变量作为新类型的 Key 值， T 类型作为 Key 的类型

type RecordlUser = Record<'age' | 'height' | 'weight', number>
// 等同于:
type ReadonlyUser = {
  age: number;
  height: number;
  weight: number;
}

条件类型

Extract<T, U> 公共类型

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

Extract<T, U> 将联合类型 T 和联合类型 U 中共有的成员组成的新联合类型，作用类似于求 T 和 U 类型的交集

type UserKey = Extract<'name' | 'age' | 'height', 'name' | 'height' | 'descrption'>
// 等同于:
type UserKey = 'name' | 'height'

Exclude<T, U> 排除类型

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

Extract<T, U> 在联合类型 T 中排除联合类型 U 中成员，类型 T 剩余的成员组成的新联合类型

type UserKey = Extract<'name' | 'age' | 'height', 'age'>
// 等同于:
type UserKey = 'name' | 'height'

Omit<T, K> 反选类型

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

Omit<T, K> 排除 T 类型中字符串字面量 K 属性后构成的新类型

interface User {
  name: string;
  age?: number;
  height?: number;
  weight: number;
}

type OmitUser = Omit<User, 'name' | 'age'>
// 等同于:
type OmitUser = {
  height?: number;
  weight: number;
}

NonNullable<T> 排除 null | undefined 类型

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

NonNullable<T> 排除 null 和 undefined 类后组成的新类型

type User = 'cat' | undefined | 'dog' | null

type NonNullableUser = NonNullable<User>;
// 等同于:
type NonNullableUser = 'cat' | 'dog';

Parameters<T> 函数参数类型

type Parameters<T extends (...args: any) => any> = T extends (...args: infer P) => any ? P : never

Parameters<T>, T类型为函数类型时，返回函数函数参数类型元组，T 为其他类型返回类型见官网

interface User {
  name: string;
  age?: number;
  height?: number;
  weight: number;
}

interface GetUser {
	(name: string, age?: string): User
}

type FunParameters = Parameters<GetUser>;
// 等同于:
type FunReturnType = [name: string, age?: string]

ReturnType<T> 函数返回值类型

type ReturnType<T extends (...args: any) => any> = T extends (...args: any) => infer R ? R : any

ReturnType<T>, T类型为函数类型时，返回函数返回值类型，T 为其他类型返回类型见官网

interface User {
  name: string;
  age?: number;
  height?: number;
  weight: number;
}

interface GetUser {
	(name: string): User
}

type FunReturnType = ReturnType<GetUser>;
// 等同于:
type FunReturnType = User