TS的高级类型

1. 接口个的 所有字段变成readonly ；

type Readonly<T> = {readonly [K in typeof T] : T[K]} ;

interface Test {
    a : {
        b : number
    }
}

const test :Readonly<Test> = {a:{b:2}} 

// test.a.b 是不会报错的
// 这个Readonly<T> type 只能限制一层的操作 需要使用递归来解决问题

type deepReadonly<T> = {
         readonly [P in keyof T] :deepReadonly<T[P]>
 }

// test.a.b  会报错

2. 把所有的字段变成可选参数

type Partiall<T> = {[P in keyof T]? : T[P]} 

3. 选择其中的字段

type Pick<T,K extends T> = {[P in keyof K] : T[P]}

4. 把所有字段变会必填参数

type Required<T> = {[K in keyof T]-?:T[K]}

5. 把所有字段类型变为指定类型

type Record<k extends any,T> = {[P in K] : T}

6.包换关系

type Exclude<T,U> = T extends U ? never : T ;

type Extract<T, U> = T extends U ? T : never;

// type T = Exclude<1 | 2, 1 | 3> // -> 2

7.Omit 用之前的 Pick 和 Exclude 进行组合, 实现忽略对象某些属性功能

type Omit<T, K> = Pick<T, Exclude<keyof T, K>>
// 使用
type Foo = Omit<{name: string, age: number}, 'name'> // -> { age: number }

解析 // 
Exclude<key of T,K> >>> Exclude<('age' | 'name'),'name'> >>> age 

8. ReturnType

type ReturnType<T extends (...arg:any) => any> = T extends (...arg:any) => infer R ? R :any

function foo(x: number): Array<number> {
  return [x];
}
type fn = ReturnType<typeof foo>; >> Number[]
type Func = () => User;
type Test = ReturnType<Func>;   // Test = User

9. 利用infer 获取构造函数的参数类型

type ConstructorParameters<T> = T extends new (...arg:infer P ) => any ? P : any

class TestClass {    constructor(      public name: string,      public string: number    ) {}  }  type Params = ConstructorParameters<typeof TestClass>;   >>> [string,number]

// 获取实例类型
type InstanceType<T> = T extends new (...arg:any) => infer P ? P : any type Params = InstanceType<typeof TestClass>;   >>> TestClass 

10. Mutable 将readonly移除

   type Mutable<T> = {-readonly [P in keyof T] : T[P]}

11 . Merge 对象合并

type O1 = {
    name: string
    id: number
}

type O2 = {
    id: number
    from: string
}

type R2 = Merge<O1, O2>