小结：近五十个常用 TypeScript类型工具 的声明、描述、用法示例

TypeScript 小结：近五十个常用TypeScript类型工具的声明、描述、用法示例

---

博文作者：李俊才（jcLee95）：https://blog.csdn.net/qq_28550263?spm=1001.2101.3001.5343
邮箱 ：291148484@163.com
本文地址：https://blog.csdn.net/qq_28550263/article/details/130299891

---

---

本文总结 TypeScript 中常用的类型工具。其中很多类型工具，在 TypeScript 中已经自带性地声明，可以直接使用。

1. 总览

类型工具	描述
Partial<T>	构造T的所有属性都设置为可选的类型。
Required<T>	构造T的所有属性都设置为required的类型。
Readonly<T>	构造T的所有属性都设置为readonly的类型。
Record<K, T>	用T类型的一组属性K构造一个类型。
Pick<T, K>	通过从T中选取属性集K来构造类型。
Omit<T, K>	通过从K中省略属性集K来构造类型。
Exclude<T, U>	通过从T中排除所有可赋给U的属性来构造类型。
Extract<T, U>	通过从T中提取所有可赋给U的属性来构造类型。
NonNullable<T>	通过从 T 中排除 null 和 undefined 来构造类型。
ReturnType<T>	构造一个由函数 T 的返回类型组成的类型。
Parameters<T>	构造一个元组类型，由函数 T 的参数类型组成。
ConstructorParameter<T>	构造一个元组类型，由构造函数t的参数类型组成。
ThisType<T>	构造一个表示函数中 this 类型的类型。
RequiredKeys<T>	构造一个由所需的 T 的键组成的类型。
Mutable<T>	构造 T 的所有属性都设置为可变的类型。
RequiredExcept<T, K>	构造T的所有属性都设置为 required 的类型，k中指定的属性除外。
ReadonlyExcept<T, K>	构造 T 的所有属性都设置为 readonly 的类型，K中指定的属性除外。
MutableExcept<T, K>	构造一个类型，其中 T 的所有属性都设置为可变，K 中指定的属性除外。
PickByValue<T, V>	通过选取值为 V 类型的 T 的属性来构造类型。
OmitByValue<T, V>	通过省略 T 的值为 V 类型的属性来构造类型。
Intersection<T, U>	构造一个由 T 和 U 中的所有属性组成的类型。
Diff<T, U>	构造一个类型，它包含T中但U中没有的所有属性。
Subtract<T, U>	构造一个类型，由T中但不在 T 和 U 的交集中的所有属性组成。
Overwrite<T, U>	构造一个由 T 和 U 的所有属性组成的类型，其中 U 的属性覆盖 T 的同名属性。
UnionToIntersection<T>	构造一个类型，该类型由 T 中所有类型的交集中的所有属性组成。
FunctionKeys	造一个由T的键组成的类型，这些键是函数。
NonFunctionKeys	构造一个由 T 的非函数键组成的类型。
PromiseType	构造一个由 Promise-like 类型 T 的已解析类型组成的类型。
DeepReadonly<T>	构造一个 T 的所有属性都递归设置为只读的类型。
DeepPartial<T>	递归地构造 T 的所有属性都设置为可选的类型。
ValueOf<T>	构造由 T 中所有值的并集组成的类型。
OptionalKeys<T>	构造一个由 T 的可选键组成的类型。
ReadonlyKeys<T>	构造一个由 T 的只读键组成的类型。
WritableKeys	构造一个由 T 的可写键组成的类型。
DeepRequired<T>	递归地构造 T 的所有属性都设置为 required 的类型。
DeepWritable<T>	构造 T 的所有属性都设置为可递归写的类型。
DeepNonNullable	构造一个类型，其中 T 的所有属性都递归地设置为 non-nullable。
Immutable<T>	构造 T 的所有属性都设置为不可变的类型。
Unionize	构造 T 中所有可能的性质排列的联合类型。
Exclusive<T, U>	通过从 T 中挑选所有不属于 T 或 U 的属性来构造类型。
Intersect<T, U>	通过从 T 中选取所有也在 U 中的属性来构造类型。
Assign<T, U>	通过从 T 和 U 中选取所有属性并将它们合并在一起来构造一个类型。
DeepMutable<T>	构造一个 T 的所有属性都设置为可变递归的类型。
Promisable<T>	构造一个 T 的所有属性都设置为 Promisable 的类型。
Awaited<T>	构造一个类型，将 T 的所有属性设置为 awaited 类型。
Brand<T, U>	通过用附加的 U 类型包装 T 来构造一个标称类型。
NonUndefined<T>	通过从 T 中选取所有未定义的属性来构造类型。

2. 详解

2.1 Partial<T>

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

构造T的所有属性都设置为可选的类型。

示例：

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

 type PartialUser = Partial<User>;

PartialUser 相当于:

{
  name?: string | undefined;
  age?: number | undefined;
}

2.2 Required<T>

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

构造T的所有属性都设置为required的类型。

示例：

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

type RequiredUser = Required<User>;

RequiredUser 相当于:

{
 name: string;
 age: number;
}

2.3 Readonly<T>

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

构造T的所有属性都设置为readonly的类型。

示例：

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

type ReadonlyUser = Readonly<User>;

ReadonlyUser 相当于:

{
 readonly name: string;
 readonly age: number;
}

2.4 Record<K, T>

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

用T类型的一组属性K构造一个类型。

示例：

type User = {
  name: string;
  age: number;
}

type UserRecord = Record<string, User>;

UserRecord 相当于:

{
  [x: string]: User;
}

2.5 Pick<T, K>

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

> 通过从T中选取属性集K来构造类型。
 
 示例：
 interface User {
   name: string;
   age: number;
   email: string;
 }
 
 type UserWithoutEmail = Pick<User, 'name' | 'age'>;

UserWithoutEmail 相当于:

 {
   name: string;
   age: number;
 }

2.6 Omit<T, K>

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

通过从K中省略属性集K来构造类型。

示例：

interface User {
  name: string;
  age: number;
  email: string;
}

type UserWithoutEmail = Omit<User, 'email'>;

UserWithoutEmail 相当于:

{
  name: string;
  age: number;
}

2.7 Exclude<T, U>

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

通过从T中排除所有可赋给U的属性来构造类型。

示例：

type User = {
  name: string;
  age: number;
  email: string | null;
}

type UserWithoutNullableEmail = Exclude<User, { email: null }>;

UserWithoutNullableEmail 相当于:

{
  name: string;
  age: number;
  email: string;
}

2.8 Extract<T, U>

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

通过从T中提取所有可赋给U的属性来构造类型。

示例：

type User = {
  name: string;
  age: number;
  email: string | null;
}

type UserWithNullableEmail = Extract<User, { email: null }>;

UserWithNullableEmail 相当于:

{
  name: string;
  age: number;
  email: string | null;
}

2.9 NonNullable<T>

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

通过从 T 中排除 null 和 undefined 来构造类型。

示例：

type User = {
  name: string;
  age: number;
  email: string | null;
}

type UserWithNonNullEmail = {
  [K in keyof User]: NonNullable<User[K]>;
};

UserWithNonNullEmail 相当于:

{
  name: string;
  age: number;
  email: string;
}

2.10 ReturnType<T>

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

构造一个由函数 T 的返回类型组成的类型。

示例：

function getUser() {
  return {
    name: 'John',
    age: 30,
  };
}

type User = ReturnType<typeof getUser>;

User 相当于:

{
  name: string;
  age: number;
}

2.11 Parameters<T>

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

构造一个元组类型，由函数 T 的参数类型组成。

示例：

function updateUser(name: string, age: number) {
  ...
}

type UpdateUserParams = Parameters<typeof updateUser>;

UpdateUserParams 相当于:

[string, number]

2.12 ConstructorParameter<T>

type ConstructorParameters<T extends new (...args: any[]) => any> = T extends new (...args: infer P) => any ? P : never;

构造一个元组类型，由构造函数t的参数类型组成。

示例：

class User {
  constructor(name: string, age: number) {
    ...
  }
}

type UserConstructorParams = ConstructorParameters<typeof User>;

UserConstructorParams 相当于:

[string, number]

2.13 ThisType<T>

type ThisType<T> = { [K in keyof T]: T[K] } & { new(...args: any[]): T };

构造一个表示函数中 this 类型的类型。

示例：

interface User {
  name: string;
  age: number;
  greet(this: User): void;
}

const user: User = {
  name: 'John',
  age: 30,
  greet() {
    console.log(`Hello, my name is ${this.name} and I am ${this.age} years old.`);
  },
};

user.greet(); logs "Hello, my name is John and I am 30 years old."

2.14 RequiredKeys<T>

type RequiredKeys<T> = {
  [K in keyof T]-?: {} extends Pick<T, K> ? never : K
}[keyof T];

构造一个由所需的 T 的键组成的类型。

示例：

interface User {
  name: string;
  age?: number;
  email?: string;
}

type RequiredUserKeys = RequiredKeys<User>;

RequiredUserKeys 相当于:

'name'

2.15 Mutable<T>

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

构造 T 的所有属性都设置为可变的类型。

示例：

interface User {
  readonly name: string;
  readonly age: number;
}

type MutableUser = Mutable<User>;

MutableUser 相当于:

{
  name: string;
  age: number;
}

2.16 RequiredExcept<T, K>

type RequiredExcept<T, K extends keyof T> = {
  [P in keyof T]-?: P extends K ? T[P] : NonNullable<T[P]>;
};

构造T的所有属性都设置为 required 的类型，k中指定的属性除外。

示例：

interface User {
  name?: string;
  age?: number;
  email?: string;
}

type RequiredUserExceptEmail = RequiredExcept<User, 'email'>;

RequiredUserExceptEmail 相当于:

{
  name: string;
  age: number;
  email?: string;
}

2.17 ReadonlyExcept<T, K>

type ReadonlyExcept<T, K extends keyof T> = {
  readonly [P in keyof T]-?: P extends K ? T[P] : T[P];
};

构造 T 的所有属性都设置为 readonly 的类型，K中指定的属性除外。

示例：

interface User {
  readonly name: string;
  readonly age: number;
  readonly email: string;
}

type MutableUserExceptEmail = ReadonlyExcept<User, 'email'>;

MutableUserExceptEmail 相当于:

{
  readonly name: string;
  readonly age: number;
  email: string;
}

2.18 MutableExcept<T, K>

type MutableExcept<T, K extends keyof T> = {
  -readonly [P in keyof T]-?: P extends K ? T[P] : T[P];
};

构造一个类型，其中 T 的所有属性都设置为可变，K 中指定的属性除外。

示例：

interface User {
  readonly name: string;
  readonly age: number;
  readonly email: string;
}

type MutableUserExceptEmail = MutableExcept<User, 'email'>;

MutableUserExceptEmail 相当于:

{
  name: string;
  age: number;
  email: string;
}

2.19 PickByValue<T, V>

type PickByValue<T, V> = Pick<T, { [P in keyof T]-?: T[P] extends V ? P : never }[keyof T]>;

通过选取值为 V 类型的 T 的属性来构造类型。

示例：

interface User {
  name: string;
  age: number;
  email: string | null;
}

type UserWithEmail = PickByValue<User, string>;

UserWithEmail 相当于:

{
  name: string;
  email: string | null;
}

2.20 OmitByValue<T, V>

通过省略 T 的值为 V 类型的属性来构造类型。

示例：

interface User {
  name: string;
  age: number;
  email: string | null;
}

type UserWithoutEmail = OmitByValue<User, string | null>;

UserWithoutEmail 相当于:

{
  age: number;
}

type OmitByValue<T, V> = Pick<T, { [P in keyof T]-?: T[P] extends V ? never : P }[keyof T]>;

2.21 Intersection<T, U>

type Intersection<T, U> = Pick<T & U, keyof T & keyof U>;

构造一个由 T 和 U 中的所有属性组成的类型。

示例：

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

interface Admin {
  name: string;
  age: number;
  role: string;
}

type UserAndAdmin = Intersection<User, Admin>;

UserAndAdmin 相当于:

{
  name: string;
  age: number;
}

2.22 Diff<T, U>

type Diff<T, U> = Pick<T, Exclude<keyof T, keyof U>>;

构造一个类型，它包含T中但U中没有的所有属性。

示例：

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

interface Admin {
  name: string;
  age: number;
  role: string;
}

type UserWithoutAdmin = Diff<User, Admin>;

UserWithoutAdmin 相当于:

{
  name: string;
  age: number;
}

2.23 Subtract<T, U>

type Subtract<T, U> = Pick<T, Exclude<keyof T, keyof U>>;

构造一个类型，由T中但不在 T 和 U 的交集中的所有属性组成。

示例：

interface User {
  name: string;
  age: number;
  email: string;
}

interface Admin {
  name: string;
  age: number;
  role: string;
}

type UserWithoutCommon = Subtract<User, Admin>;

UserWithoutCommon 相当于:

{
  email: string;
}

2.24 Overwrite<T, U>

type Overwrite<T, U> = Pick<T, Exclude<keyof T, keyof U>> & U;

构造一个由 T 和 U 的所有属性组成的类型，其中 U 的属性覆盖 T 的同名属性。

示例：

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

interface PartialUser {
  name?: string;
}

type UserWithPartial = Overwrite<User, PartialUser>;

UserWithPartial 相当于:

{
  name?: string;
  age: number;
}

2.25 UnionToIntersection<T>

type UnionToIntersection<T> = (T extends any ? (x: T) => any : never) extends (x: infer R) => any ? R : never;

构造一个类型，该类型由 T 中所有类型的交集中的所有属性组成。

示例：

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

interface Admin {
  name: string;
  role: string;
}

type UserAndAdminIntersection = UnionToIntersection<User | Admin>;

UserAndAdminIntersection 相当于:

{
  name: string;
}

2.26 FunctionKeys

构造一个由T的键组成的类型，这些键是函数。

示例：

interface User {
  name: string;
  age: number;
  greet(): void;
}

type UserFunctionKeys = FunctionKeys<User>;

UserFunctionKeys 相当于:

'greet'
type FunctionKeys<T> = { [K in keyof T]: T[K] extends Function ? K : never }[keyof T];

2.27 NonFunctionKeys

type NonFunctionKeys<T> = { [K in keyof T]: T[K] extends Function ? never : K }[keyof T];

构造一个由 T 的非函数键组成的类型。

示例：

interface User {
  name: string;
  age: number;
  greet(): void;
}

type UserNonFunctionKeys = NonFunctionKeys<User>;

UserNonFunctionKeys 相当于:

'name' | 'age'

2.28 PromiseType

type PromiseType<T extends Promise<any>> = T extends Promise<infer U> ? U : never;

构造一个由 Promise-like 类型 T 的已解析类型组成的类型。

示例：

type User = {
  name: string;
  age: number;
};

type UserPromise = Promise<User>;

type UserResolved = PromiseType<UserPromise>;

UserResolved 相当于:

{
  name: string;
  age: number;
}

2.29 DeepReadonly<T>

type DeepReadonly<T> = {
  readonly [P in keyof T]: T[P] extends object ? DeepReadonly<T[P]> : T[P];
};

构造一个 T 的所有属性都递归设置为只读的类型。

示例：

interface User {
  name: string;
  age: number;
  address: {
    street: string;
    city: string;
  };
}

type DeepReadonlyUser = DeepReadonly<User>;

DeepReadonlyUser 相当于:

{
  readonly name: string;
  readonly age: number;
  readonly address: {
    readonly street: string;
    readonly city: string;
  };
}

2.30 DeepPartial<T>

type DeepPartial<T> = {
  [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
};

递归地构造 T 的所有属性都设置为可选的类型。

示例：

interface User {
  name: string;
  age: number;
  address: {
    street: string;
    city: string;
  };
}

type DeepPartialUser = DeepPartial<User>;

DeepPartialUser 相当于:

{
  name?: string;
  age?: number;
  address?: {
    street?: string;
    city?: string;
  };
}

2.31 ValueOf<T>

type ValueOf<T> = T[keyof T];

构造由 T 中所有值的并集组成的类型。

示例：

type User = {
  id: number;
  name: string;
};
//
type UserValues = ValueOf<User>;

UserValues 相当于:

number | string

2.32 OptionalKeys<T>

type OptionalKeys<T> = { [K in keyof T]-?: {} extends Pick<T, K> ? K : never }[keyof T];

构造一个由 T 的可选键组成的类型。

示例：

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

type UserOptionalKeys = OptionalKeys<User>;

UserOptionalKeys 相当于:

'age'

2.33 ReadonlyKeys<T>

type ReadonlyKeys<T> = { [K in keyof T]-?: T[K] extends Readonly<T[K]> ? K : never }[keyof T];

构造一个由 T 的只读键组成的类型。

示例：

interface User {
  readonly id: number;
  name: string;
  age?: number;
}

type UserReadonlyKeys = ReadonlyKeys<User>;

UserReadonlyKeys 相当于:

'id'

2.34 WritableKeys

type WritableKeys<T> = { [K in keyof T]-?: T[K] extends Readonly<T[K]> ? never : K }[keyof T];

构造一个由 T 的可写键组成的类型。

示例：

interface User {
  readonly id: number;
  name: string;
  age?: number;
}

type UserWritableKeys = WritableKeys<User>;
UserWritableKeys 相当于:
'name' | 'age'

2.35 DeepRequired<T>

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

递归地构造 T 的所有属性都设置为 required 的类型。

示例：

interface User {
  name?: string;
  age?: number;
  address?: {
    street?: string;
    city?: string;
  };
}

type DeepRequiredUser = DeepRequired<User>;

DeepRequiredUser 相当于:

{
  name: string;
  age: number;
  address: {
    street: string;
    city: string;
  };
}

2.36 DeepWritable<T>

type DeepWritable<T> = {
  -readonly [P in keyof T]-?: T[P] extends object ? DeepWritable<T[P]> : T[P];
};

构造 T 的所有属性都设置为可递归写的类型。

示例：

interface User {
  readonly name?: string;
  readonly age?: number;
  readonly address?: {
    readonly street?: string;
    readonly city?: string;
  };
}

type DeepWritableUser = DeepWritable<User>;

DeepWritableUser 相当于:

{
  name?: string;
  age?: number;
  address?: {
    street?: string;
    city?: string;
  };
}

2.37 DeepNonNullable

type DeepNonNullable<T> = {
  [P in keyof T]-?: NonNullable<T[P]> extends object ? DeepNonNullable<NonNullable<T[P]>> : NonNullable<T[P]>;
};

构造一个类型，其中 T 的所有属性都递归地设置为 non-nullable。

示例：

interface User {
  name?: string;
  age?: number | null;
  address?: {
    street?: string;
    city?: string | null;
  };
}

type DeepNonNullableUser = DeepNonNullable<User>;

DeepNonNullableUser 相当于:

{
  name: string;
  age: number;
  address: {
    street: string;
    city: string;
  };
}

2.38 Immutable<T>

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

构造 T 的所有属性都设置为不可变的类型。

示例：

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

type ImmutableUser = Immutable<User>;

ImmutableUser 相当于:

{
  readonly name: string;
  readonly age: number;
}

2.39 Unionize

type Unionize<T> = T extends any ? (k: T) => void : never extends (k: infer U) => void ? U : never;

构造 T 中所有可能的性质排列的联合类型。

示例：

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

type UserUnion = Unionize<User>;

UserUnion 相当于:

{
  id: number;
} | {
  id: number;
  name: string;
} | {
  id: number;
  age: number;
} | {
  id: number;
  name: string;
  age: number;
}

2.40 Exclusive<T, U>

type Exclusive<T, U> = (Diff<T, U> & U) | (Diff<U, T> & T);

通过从 T 中挑选所有不属于 T 或 U 的属性来构造类型。

示例：

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

type UserWithNameOrEmail = Exclusive<User, { name: any; email: any }>;

UserWithNameOrEmail 相当于:

{
  id: number;
  name: string;
  age: number;
} | {
  id: number;
  email: any;
}

2.41 Intersect<T, U>

type Intersect<T, U> = Pick<T, Extract<keyof T, keyof U> & Extract<keyof U, keyof T>>;

通过从 T 中选取所有也在 U 中的属性来构造类型。

示例：

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

type UserWithName = Intersect<User, { name: any }>;

UserWithName 相当于:

{
  name: string;
}

2.42 Assign<T, U>

type Assign<T, U> = T & U;

通过从 T 和 U 中选取所有属性并将它们合并在一起来构造一个类型。

示例：

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

type UserWithEmail = Assign<User, { email: string }>;

UserWithEmail 相当于:

{
  id: number;
  name: string;
  age: number;
  email: string;
}

2.43 DeepMutable<T>

type DeepMutable<T> = {
  -readonly [P in keyof T]: T[P] extends object ? DeepMutable<T[P]> : T[P];
};

构造一个 T 的所有属性都设置为可变递归的类型。

示例：

interface User {
  readonly name?: string;
  readonly age?: number;
  readonly address?: {
    readonly street?: string;
    readonly city?: string;
  };
}

type DeepMutableUser = DeepMutable<User>;

DeepMutableUser 相当于:

{
  name?: string;
  age?: number;
  address?: {
    street?: string;
    city?: string;
  };
}

2.44 Promisable<T>

type Promisable<T> = {
  [P in keyof T]: Promise<T[P]>;
};

构造一个 T 的所有属性都设置为 Promisable 的类型。

示例：

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

type PromisableUser = Promisable<User>;

PromisableUser 相当于:

{
  name: Promise<string>;
  age: Promise<number>;
}

2.45 Awaited<T>

type Awaited<T> = {
  [P in keyof T]: T[P] extends Promise<infer U> ? U : never;
};

构造一个类型，将 T 的所有属性设置为 awaited 类型。

示例：

interface User {
  name: Promise<string>;
  age: Promise<number>;
}

type AwaitedUser = Awaited<User>;

AwaitedUser 相当于:

{
  name: string;
  age: number;
}

2.46 Brand<T, U>

type Brand<T, U> = T & { __brand: U };

通过用附加的 U 类型包装 T 来构造一个标称类型。

示例：

type Email = Brand<string, 'email'>;
const email: Email = 'john.doe@example.com';

2.47 NonUndefined<T>

type NonUndefined<T> = T extends undefined ? never : T;

通过从 T 中选取所有未定义的属性来构造类型。

示例：

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

type UserWithoutUndefined = NonUndefined<User>;

UserWithoutUndefined 相当于:

{
  name: string;
  age: number;
}