Record

Record<keyType, valueType>Record的内部定义，接收两个泛型参数；Record后面的泛型就是对象键和值的类型。
定义一个对象的 key 和 value 类型该怎么做呢？这时候就需要用到 TS 的 Record 了。
源码：

1
2
3
4
type Record<K extends string | number | symbol, T> = {
    [P in K]: T;
}

1
2
3
4
5
6
7
8
9
10
11
interface PageInfo {
  title: string;
}

type Page = "home" | "about" | "contact";

const nav: Record<Page, PageInfo> = {
  about: { title: "about" },
  contact: { title: "contact" },
  home: { title: "home" },
};
1
2
3
4
5
6
type keys = 'A' | 'B' | 'C'
const result: Record<keys, number> = {
  A: 1,
  B: 2,
  C: 3
}

Partial

Partial<T>作用：生成一个新类型，该类型与 T 拥有相同的属性，但是所有属性皆为可选项。
源码：

1
2
3
type Partial<T> = {
    [P in kefof T]?: T[P]
}
1
2
3
4
5
6
7
8
9
10
interface Foo {
    name: string;
    age: number;
}
type Bar = Partial<Foo>
// 相当于
type Bar = {
    name?: string;
    age?: number;
}

Required

Required<T>作用：生成一个新类型，该类型与 T 拥有相同的属性，但是所有属性皆为必选项。
源码：

1
2
3
type Require<T> = {
    [p in keyof T]-?: T[P]
}
1
2
3
4
5
6
7
8
9
10
interface Foo {
    name: string;
    age?: number;
}
type Bar = Partial<Foo>
// 相当于
type Bar = {
    name: string;
    age: number;
}

Readonly

Readonly<T>作用：生成一个新类型，T 中的 K 属性是只读的，K 属性是不可修改的。
源码：

1
2
3
type Require<T> = {
    [p in keyof T]-?: T[P]
}
1
2
3
4
5
6
7
8
9
10
interface Todo {
  title: string;
}

const todo: Readonly<Todo> = {
  title: "Delete inactive users",
};

todo.title = "Hello";
// Cannot assign to 'title' because it is a read-only property.

Pick

Pick<T, Keys>作用：生成一个新类型，该类型拥有 T 中的 K 属性集 。
源码：

1
2
3
type Pick<T, K extends keyof T> = {
    [P in K]: T[P];
};
1
2
3
4
5
6
7
8
9
10
11
12
interface Todo {
  title: string;
  description: string;
  completed: boolean;
}

type TodoPreview = Pick<Todo, "title" | "completed">;

const todo: TodoPreview = {
  title: "Clean room",
  completed: false,
};

Exclude

Exclude<T, U>作用：从T类型中排除U类型生成的新类型（相当于取差集）。
源码：

1
type Exclude<T, U> = T extends U ? never : T
1
2
3
4
5
6
type A = number | string | boolean
type B = number | boolean

type Foo = Exclude<A, B>
// 相当于
type Foo = string;

Extract

和 Exclude 相反（相当于取交集）。
源码：

1
type Extract<T, U> = T extends U ? T : never
1
2
3
4
type T0 = Extract<"a" | "b" | "c", "a" | "f">;
// 相当于  type T0 = "a"
type T1 = Extract<string | number | (() => void), Function>;
// 相当于  type T1 = () => void

Omit

Omit<T, keysType>作用：生成一个新类型，该类型拥有 T 中除了 keysType 属性以外的所有属性。
源码：

1
type Omit<T, K extends keyof any> = Pick<T, Exclude<keyof T, K>> 
1
2
3
4
5
6
7
8
9
10
type Foo = {
	name: string
	age: number
}

type Bar = Omit<Foo, 'age'>
// 相当于
type Bar = {
	name: string
}

NonNullable

NonNullable<T>作用：从泛型 T 中排除掉 null 和 undefined。
源码：

1
NonNullable<T>
1
2
3
4
type NonNullable<T> = T extends null | undefined ? never : T;

type t = NonNullable<'name' | undefined | null>;
/* type t = 'name' */

Parameters

Parameters<T>从函数类型T的参数中使用的类型构造元组类型。
源码：

1
Parameters<T extends (...args: any) => any>
1
2
3
type t = Parameters<(name: string) => any>; // type t = [string]

type t2 = Parameters<((name: string) => any)  | ((age: number) => any)>; // type t2 = [string] | [number]

ConstructorParameters

ConstructorParameters<T>从构造函数类型T的参数中使用的类型构造元组类型。
源码：

1
ConstructorParameters<T extends new (...args: any) => any>
1
2
type t = ConstructorParameters<(new (name: string) => any)  | (new (age: number) => any)>;
// type t = [string] | [number]

ReturnType

ReturnType<T>作用：获得函数返回值的类型。
源码：

1
type ReturnType<T extends (...args: any) => any> = T extends (...args: any) => infer R ? R : any;
1
2
3
4
5
6
7
8
9
10
11
type t = ReturnType<(name: string) => string | number>;
// type t = string | number;

type T0 = ReturnType<() => string>; // string
type T1 = ReturnType<(s: string) => void>; // void
type T2 = ReturnType<<T>() => T>; // {}
type T3 = ReturnType<<T extends U, U extends number[]>() => T>; // number[]
type T4 = ReturnType<any>; // any
type T5 = ReturnType<never>; // any
type T6 = ReturnType<string>; // Error
type T7 = ReturnType<Function>; // Error

InstanceType

源码：

1
InstanceType<T extends new (...args: any) => any>

InstanceType<T>用于获取构造函数的返回值类型。

1
2
3
4
5
6
7
type t = InstanceType<new (name: string) => {name: string, age: number}>
/* 相当于
type t = {
    name: string;
    age: number;
}
*/