条件类型

// T extends U ? X : Y
// 含义如果类型 T 可以被赋值给类型 U 结果类型就是 X类型 不然就是 Y类型

type TypeName<T> = 
  T extends string ? 'string' :
  T extends number ? 'number' :
  T extends boolean ? 'boolean' :
  T extends undefined ? 'undefined' :
  T extends Function ? 'function' :
  'object';

  type T1 = TypeName<string>   // type T1 = "string"
  type T2 = TypeName<string[]>  // type T2 = "object"


  // 联合类型 
  // (A | B) extends U ? X : Y
  // 可以拆解成：
  // (A extends U ? X : Y) | (B extends U ? X : Y)
 
  // 分布式条件类型 
  type T3 = TypeName<string | string[]>   // type T3 = "string" | "object"
 
  // Diff类型 T可以赋值给U 可以就是never类型 否则就是T类型
  type Diff<T, U> = T extends U ? never : T

  // 联合类型 
  type T4 = Diff<'a' | 'b' | 'c','a' | 'e'>  // type T4 = "b" | "c"
  // 多个条件的联合类型
  // Diff<'a' ,'a' | 'e'> | Diff<'b' ,'a' | 'e'> | Diff<'c' ,'a' | 'e'>
  // never | 'b' | 'c' 
  // 'b' | 'c'

 
  // Diff类型 去除不需要的类型 
  // 定义一个NotNull类型 去除undefined | null
  type NotNull<T> = Diff<T, undefined | null>

  // T5的类型就是string | number
  type T5 = NotNull<string | number | undefined | null> // type T5 = string | number






  // 官方内置类型
  // 从类型T中过滤掉可以赋值给U的类型
  // Exclude<T, U>
  // NonNullable<T>
  // 从类型T中过抽取出可以赋值给U的类型
  // Extract<T, U>

  type T6 = Extract<'a' | 'b' | 'c', 'a' | 'e'>   // type T6 = "a"

  // 获取函数返回值的类型
  // ReturnType<T>
  type T7 = ReturnType<() => string>  // type T7 = string