博文作者：李俊才（jcLee95）：https://blog.csdn.net/qq_28550263?spm=1001.2101.3001.5343
邮箱 ：291148484@163.com
本文地址：https://blog.csdn.net/qq_28550263/article/details/130299891
目 录
- 1. 总览
- 2. 详解
- 2.1 Partial\<T>
- 2.2 Required\<T>
- 2.3 Readonly\<T>
- 2.4 Record<K, T>
- 2.5 Pick<T, K>
- 2.6 Omit\<T, K>
- 2.7 Exclude\<T, U>
- 2.8 Extract\<T, U>
- 2.9 NonNullable\<T>
- 2.10 ReturnType\<T>
- 2.11 Parameters\<T>
- 2.12 ConstructorParameter\<T>
- 2.13 ThisType\<T>
- 2.14 RequiredKeys\<T>
- 2.15 Mutable\<T>
- 2.16 RequiredExcept\<T, K>
- 2.17 ReadonlyExcept\<T, K>
- 2.18 MutableExcept\<T, K>
- 2.19 PickByValue\<T, V>
- 2.20 OmitByValue\<T, V>
- 2.21 Intersection\<T, U>
- 2.22 Diff\<T, U>
- 2.23 Subtract\<T, U>
- 2.24 Overwrite\<T, U>
- 2.25 UnionToIntersection\<T>
- 2.26 FunctionKeys<T>
- 2.27 NonFunctionKeys<T>
- 2.28 PromiseType<T>
- 2.29 DeepReadonly\<T>
- 2.30 DeepPartial\<T>
- 2.31 ValueOf\<T>
- 2.32 OptionalKeys\<T>
- 2.33 ReadonlyKeys\<T>
- 2.34 WritableKeys<T>
- 2.35 DeepRequired\<T>
- 2.36 DeepWritable\<T>
- 2.37 DeepNonNullable<T>
- 2.38 Immutable\<T>
- 2.39 Unionize<T>
- 2.40 Exclusive\<T, U>
- 2.41 Intersect<T, U>
- 2.42 Assign\<T, U>
- 2.43 DeepMutable\<T>
- 2.44 Promisable\<T>
- 2.45 Awaited\<T>
- 2.46 Brand\<T, U>
- 2.47 NonUndefined\<T>
本文总结 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;
}
