泛型工具

// 泛型工具
interface user {
  name: string
  age: number
  sex: string
}
interface rUser {
  name?: string
  age?: number
  sex?: string
}

// Partial<泛型> 把所有属性改为可选属性
type PUser = Partial<user>
// {
//   name?: string
//   age?: number
//   sex?: string
// }
// 源码
// type CustomPartial<T>  = {
//   [p in keyof T]?: T[p]
// }
// type PUser = CustomPartial<user>

// Required<泛型>把所有属性改为必选属性
type RUser = Required<rUser>
// {
//   name: string
//   age: number
//   sex: string
// }
// 源码,-?代表减去可选....
// type CustomRequired<T> = {
//   [p in keyof T]-?: T[p]
// }
// type RUser = Required<rUser>

// Pick<interface,选中的属性>，取属性出来
// type CustomPick = Pick<user, 'age'>
// {
//   age: number
// }
// 可接受联合类型
type pickUser = Pick<user, 'age' | 'name'>
// {
//   age: number
//   name: string
// }
// 源码,传入K
// type CustomPick<T, K extends keyof T> = {
//   [p in K]: T[p]
// }
// type pickUser = CustomPick<user, 'age' | 'name'>

// Exclude<类型,需要排除的类型>，取被排除后的类型
// type excludeUser = Exclude<'a'|'b'|'c','a'>
// 'b'|'c'
// 可接受联合类型
type excludeUser = Exclude<'a'|'b'|'c','a'|'c'>
// 'b'
// 源码,T属于K的返回nerve,never在联合类中自动会去除
// type CustomExclude<T,K> = T extends K ? never : T
// type excludeUser = CustomExclude<'a'|'b'|'c','a'|'c'>

// Omit跟exclude差不多，不同的是Omit传入的是interface，Omit<interface,需要排除的属性>
type omitUser = Omit<user, 'age'>
// {
//   name: string
//   sex: string
// }
// 可接受联合类型
// type omitUser = Omit<user,'age' | 'sex'>
// {
//   name: string
// }
// type CutomOmit<T, K extends keyof T> = Pick<T,Exclude<keyof T, K>>
// type omitUser = CutomOmit<user, 'age'>

// Record是约束对象的key和value,
// key是要求必须全部要存在、并且只能是number、string、symbol类型
// value不要求全部存在，但是只可以是定义的值
type key = 'a'| 'b'
type value = '跳舞' | '唱歌'
// const obj:Record<key,value> = {
//   'a': '唱歌',
//   'b': '唱歌'
// }
// 可以嵌套
const obj:Record<key,Record<key,value>> = {
  'a': {
    'a': '唱歌',
    'b': '跳舞'
  },
  'b': {
    'a': '唱歌',
    'b': '唱歌'
  }
}
// 源码 
// type normal = keyof any // 会推断为 string、number、symbol
// type customRecord<T extends normal,K> = {
//   [p in T]: K
// }
// const obj:customRecord<key,customRecord<key,value>> = {
//   'a': {
//     'a': '唱歌',
//     'b': '跳舞'
//   },
//   'b': {
//     'a': '唱歌',
//     'b': '唱歌'
//   }
// }

// ReturnType是获取函数的返回值类型
const fn = () => [1, 2, 3, '222']
type rt = ReturnType<typeof fn>
// (string | number)[]
// 源码
// 1.T接受的是函数类型
// 2.函数返回值推断有值则是返回该值，没有的话是never
type CustomReturnType<T extends Function> = T extends (...arg:any[]) => infer Res ? Res : never