交叉类型

两个对象创建一个新对象拥有两个对象类型。

  1. interface IAnyObject{
  2.   [prop:string]:any
  3. }
  4. function mixin<T extends IAnyObject,U extends IAnyObject>(first:T,second:U):T&U{
  5.   const result =<T&U>{}
  6.   for (let key in first){
  7.     (<T>result)[key]=first[key]
  8.   }
  9.   for (let key in second){
  10.     if(!result.hasownProperty(key)){
  11.       (<U>result)[key]=second[key]
  12.     }
  13.   }
  14.   return result
  15. }

联合类型

用|来分。

类型别名

可以作用于原始值，联合类型，元组及其他需要手写的类型。

索引类型

keyof 拿到对象或者类的属性名

映射类型

in 一般用来重写属性。 [ key in keys ]
k:类型变量
keys:联合类型
自带遍历

  1. // 加一个可选类型
  2. [k in key of T]?:T[K]

条件类型

  1. // 三目
  2. T extends U ?X:Y

裸类型参数

  1. type NakedUsage<T> = T extends boolean ? "YES" : "NO"
  2. type Distributed = NakedUsage<number | boolean > 
  3. // = NakedUsage<number> | NakedUsage<boolean> =  "NO" | "YES"

非裸类型参数

  1. type WrappedUsage<T> = [T] extends [boolean] ? "YES" : "NO"; 
  2. // wrapped in a tuple 包在元组里面
  3. type NotDistributed = WrappedUsage<number | boolean > // "NO"    
  4. type NotDistributed2 = WrappedUsage<boolean > // "YES"

巧用never类型和条件类型来筛选类型

映射类型
重写属性类型

infer

infer P 代表待推断的函数参数

  1. infer 用于提取函数类型的返回值类型
  2. 用于提取构造函数(实例)参数类型
    1. type param<T> = T extends (...arg:infer P)=>any?P:T
    2. interface User{
    3. name:string
    4. age:string
    5. }
    6. type Fun=(user:User)=>void
    7. type Params=param<Fun> //  User
    8. type AA =param<string> // string
    构造函数 infer p p可以数组参数
    元数组转联合类型
    1. type Element of<T>= T extends Arrary<infer E>?E:never
    联合类型转交叉类型
    仅当条件类型是裸类型的时候才会分布 多用于混入