typescript高级类型

export {}

// keyof 关键字
type Keys = keyof any;

// 交叉类型
interface A { 
  propA: number 
};
interface B { 
  propB: string 
};

// 类似继承 C extends A, B
type C = A & B; // { propA: number, propB: string }

const YY: C = {
  propA: 1,
  propB: '2'
}

// typeof 获取实例对象类型
const people = {
  name: 'keep-promise',
  age: 18,
}

type INewPeople = typeof people
// 等同于
// type INewPeople = {
//   name: number
//   age: number
// }

type TKeys = keyof typeof people;


// Record<K, P>: 定义对象属性名类型和属性值类型
type _Record<K extends keyof any, P> = {
  [P in K]: P
}

// Partial<T>: 将 T 中所有属性设置为可选
type _Partial<T> = {
  [K in keyof T]?: T[K]
}

// Required<T>:  将 T 中所有属性设置为必选
type _Required<T> = {
  [K in keyof T]-?: T[K]
}

// Pick<T, K extends keyof T>: T 类型中选取 K 类型，并返回新的类型，T 常用于对象类型，K 标识联合类型
type _Pick<T, K extends keyof T> = {
  [P in K]: T[P]
}

// Omit<T, K extends keyof T>: T 类型中排除 K 类型，并返回新的类型，T 常用于对象类型，K 标识联合类型
type _Omit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>

interface IPeople {
  name:string,
  age?: number,
}

type TOmit = Omit<IPeople, 'name'>
// 等同于
// type TOmit = {
//   age?: number | undefined;
// }


// Readonly<T>: T 中所有属性设为只读
type _Readonly<T> = {
  readonly [K in keyof T]: T[K]
}

// Exclude<T, U>: 剔除 T 中 U 的类型
type _Exclude<T, U> = T extends U ? never : T;
// 当 T 是联合类型时，则会循环 T 类型即： (T1 extends U ? never : T1) ｜ (T2 extends U ? never : T2) | …

type TExclude = Exclude<'a' | 'b', 'a' | 'c'> 
// 等同于
// type TExclude = 'b'

type TExclude2 = Exclude<number | string | boolean, string>
// 等同于
// type TExclude2 = number | boolean


// Extract<T, U>: 提取 T 中 U 含有的类型
type _Extract<T, U> = T extends U ? T : never;
// 当 T 是联合类型时，则会循环 T 类型即： (T1 extends U ? T1 : never ) ｜ (T2 extends U ? T2 : never ) | …

type TExtract = Extract<'a' | 'b', 'a' | 'c'>
// 等同于
// type TExtract = 'a';

type TExtract2 = Exclude<number | string | boolean, string>
// 等同于
// type TExtract2 = string

type TExtract3 = Extract<number | boolean, string> 
// 等同于
// type TExtract3 = never


// NonNullable<T>: 排除 null 和 undefined 类型
type _NonNullable<T> = T extends null | undefined ? never : T;
// 等价于
// type _NonNullable<T> = Exclude<T, null | undefined>

type TNonNullable = NonNullable<number | null | undefined>
// 等价于
type TNonNullable1 = Exclude<number | null | undefined, null | undefined>
// 等同于
// type TNonNullable = number;


// Parameters<T>: 获取函数类型T参数类型
type _Parameters<T extends (...args: any) => any> = T extends (...args: infer U) => void ? U : never;

type T0 = Parameters<() => void>; // []
type T1 = Parameters<(a: string) => void>; // [string]
type T2 = Parameters<(a: string, b: number) => void>; // [string, number]
type T3 = Parameters<(x: {a: string, b: number}) => void>; // [{a: string; b: number}]


// ConstructorParameters<T>: 获取构造函数类型T参数类型
type _ConstructorParameters<T extends abstract new (...args: any) => void> = 
T extends abstract new (...args: infer U) => any ? U : never;
// 使用参数类型构造一个元组类型

type CP = ConstructorParameters<new (s?: string) => object>; // [s?: string | undefined]

// ReturnType<T>: 获取函数类型T返回值类型
type _ReturnType<T extends (...args: any) => any> = T extends (...args: any) => infer U ? U : any;

type R0 = ReturnType<() => string>; // string
type R1 = ReturnType<() => { a: string, b: number }>; // { a: string; b: number }

// InstanceType<T>: 获取构造函数类型T返回值类型
type _InstanceType<T extends abstract new (...args: any) => any> = 
T extends abstract new (...args: any) => infer U ? U : any;

class AA {
  x = 0;
}

type I0 = InstanceType<typeof AA>; // AA
type I1 = InstanceType<new (s?: string) => object>; // object

// ThisParameterType<T>: 获取函数类型T中this类型
// 若函数类型定义中没有 this 参数，则返回 unknown 类型
type _ThisParameterType<T> = T extends (this: infer U, ...args: any) => any ? U : unknown;

function fn(this: object, x: number) { }
function fn1(x: number) { }
type This0 = ThisParameterType<typeof fn> // object
type This1 = ThisParameterType<typeof fn1> // unknown


// OmitThisParameter<T>: 剔除函数类型T中this参数类型，并构造一个新类型
type _OmitThisParameter<T> = 
unknown extends ThisParameterType<T> ? T : T extends (...args: infer A) => infer R ? (...args: A) => R : T

function fn22(this: object, x: number) { }

type OT0 = OmitThisParameter<typeof fn> // (x: number) => void