TypeScript 最常用10个内置工具类型及其实现

interface User { name: string; age: number }
type PartialUser = Partial<User>;
// { name?: string; age?: number }

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

type PartialUser = { name?: string }
type RequiredUser = Required<PartialUser>;
// { name: string }

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

type ReadonlyUser = Readonly<User>;
// { readonly name: string; readonly age: number }

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

type PickedUser = Pick<User, "name">;
// { name: string }

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

type OmitUser = Omit<User, "age">;
// { name: string }

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

type T = "a" | "b" | "c";
type U = "a";
type Result = Exclude<T, U>;
// "b" | "c"

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

type Result = Extract<"a" | "b" | "c", "a" | "b">;
// "a" | "b"

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

type Obj = Record<string, number>;
// { [key: string]: number }

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

const fn = () => ({ name: "zs" });
type FnReturn = ReturnType<typeof fn>;
// { name: string }

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

type Fn = (a: number, b: string) => void;
type Params = Parameters<Fn>;
// [number, string]

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