TypeScript——泛型

interface Person {
  name: string
  age?: number
  height?: number
}
type CityType = "上海" | "洛杉矶"

// type newRecordType = Record<CityType, Person>
type MyRecord<K extends keyof any, T> = {
  [P in K]: T
}
type newRecordType = MyRecord<CityType, Person>
// type newRecordType = {
//   上海: Person;
//   洛杉矶: Person;
// }

4.5 Pick<Type, Keys>

        用于构造一个类型，它是从Type类型里面挑了一些属性Keys。

interface Person {
  name: string
  age?: number
  height?: number
}

// type newPickType = Pick<Person, "name">
type MyPick<T, K extends keyof T> = {
  [P in K]: T[P]
}
type newPickType = MyPick<Person, "name" | "age">

4.6 Omit<Type, Keys>

        用于构造一个类型，它是从Type类型里面过滤了一些属性Keys。

interface Person {
  name: string
  age?: number
  height?: number
}

// type newOmitType = Omit<Person, "name">
type MyOmit<T, K extends keyof T> = {
  [P in keyof T as P extends K ? never : P]: T[P]
}
type newOmitType = MyOmit<Person, "name" | "age">

4.7 Exclude<UnionType, ExcludedMembers>

        用于构造一个类型，它是从UnionType联合类型里面排除了所有可以赋给ExcludedMembers的类型。

type PropertyTypes = "name" | "age" | "height"

// type newType = Exclude<PropertyTypes, "name">
type MyExclude<T, U> = T extends U ? never : T
type newType = MyExclude<PropertyTypes, "name">

4.8 Extract<Type, Union>

        用于构造一个类型，它是从Type类型里面提取了所有可以赋给Union的类型。

type PropertyTypes = "name" | "age" | "height"

// type newType = Extract<PropertyTypes, "name">
type MyExtract<T, U> = T extends U ? T : never
type newType = MyExtract<PropertyTypes, "name">

4.9 NonNullable<Type>

        用于构造一个类型，这个类型从Type中排除了所有的null、undefined的类型。

type PropertyTypes = "name" | "age" | "height" | null | undefined

// type newType = NonNullable<PropertyTypes>

type MyNonNullable<T> = T extends null | undefined ? never : T
type newType = MyNonNullable<PropertyTypes>

4.10 ReturnType<Type>

        用于构造一个含有Type函数的返回值的类型。

type CalcFnType = (num1: number, num2: string) => number

// type CalcReturnType = ReturnType<CalcFnType>;
type MyReturnType<T extends (...arg: any[]) => any> = T extends (
  ...arg: any[]
) => infer R
  ? R
  : never
type CalcReturnType = MyReturnType<CalcFnType>

4.11 InstanceType<Type>

        用于构造一个由所有Type的构造函数的实例类型组成的类型。

// https://stackoverflow.com/questions/70364964/difference-in-typescript-between-types-instancetypetypeof-myclass-and-myc
/**
 * 在TypeScript中, 当你创建出来一个类型的事实上你做了两件事情, 比如Person
 *  1.创建一个类class Person
 *  2.创建了两个类型
 * 哪两个类型呢?
 *  1.Person
 *  2.typeof Person: 构造函数
 */
type HYInstanceType<T extends new (...args: any[]) => any> = T extends new (
  ...args: any[]
) => infer R
  ? R
  : never

class Person {
  name: string
  age: number
  constructor(name: string, age: number) {
    this.name = name
    this.age = age
  }
}

type T = typeof Person
type PersonType = InstanceType<typeof Person>

// 对于普通的定义来说似乎是没有区别的
const info: Person = { name: "why", age: 18 }
const into2: PersonType = { name: "kobe", age: 30 }

// 但是如果我们想要做一个工厂函数, 用于帮助我们创建某种类型的对象
// 这里的返回值不可以写T, 因为T的类型会是typeof Person
// 这里就可以使用InstanceType<T>, 它可以帮助我们返回构造函数的返回值类型(构造函数创建出来的对象类型)
function factory<T extends new (...args: any[]) => any>(
  ctor: T
): HYInstanceType<T> {
  return new ctor()
}

const p1 = factory(Person)