TypeScript 中一些被忽视的内置类型

interface Person {
  name: string
  age?: number
}

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

// Partial<Person> -> { name?: string; age?: number }

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

// Required<Person> -> { name: string; age: number }

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

// Readonly<Person> -> { readonly name: string; readonly age?: number }

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

// Pick<Person, 'name'> -> { name: string }
// Pick<Person, 'name' | 'age> -> { name: string; age?: number }

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

// Record<'a' | 'b' | 'c', Person> -> { a: Person; b: Person; c: Person; }

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

// Exclude<'admin' | 'guest', 'guest'> -> "admin"

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

// Extract<'admin' | 'guest', 'guest'> -> "guest"

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

// Omit<Person, 'age'> -> { name: string }

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

// NonNullable<'a' | 'b' | null> -> "a" | "b"

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

function foo(a: string, b: number) {}
// Parameters<typeof foo> -> [string, number]

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

function foo(x: number): number[] {
  return [x]
}
// ReturnType<typeof foo> -> number[]