内置工具的使用和具体实现过程

    # TS内置工具的使用和具体实现过程

今天学习到了ts中的一些内置工具，虽然在开发中使用的不多，但是了解一下并且通过做类型体操把它实现能很大程度的提升对ts中类型的使用。直接上代码。

1.内置工具Partial

作用：用于构造一个Type下面的所有属性都设置为可选值

    interface IKUN{
        name:string
        age:number
        slogan?:string
    }
    // 内置工具使用：
    type IKUNOptional = Partial<IKUN>

    // 类型体操实现
    type MyRartial<T> = {
        //使用映射类型  keyof 是从对象类型中取出所有的key，组成一个联合类型
        [P in keyof T]?: T[P]
    }

    export{}

2.内置工具Required

作用：用于构造一个Type下面的所有属性都设置为必选值

    interface IKUN{
        name?:string
        age?:number
        slogan?:string
    }

    // 内置工具使用：
    type IKUNOptional =Required<IKUN>

    // 类型体操实现
    type MyRequired<T> = {
        //使用映射类型
        [P in keyof T]: T[P]
    }
    export{}

3.内置工具readonly

作用：用于构造一个Type下面的所有属性都设置为仅可读

    interface IKUN{
        name?:string
        age?:number
        slogan?:string
    }

    // 内置工具使用：
    type IKUNOptional =Required<IKUN>

    // 类型体操实现
    type Myreadonly<T> = {
         readonly [P in keyof T]: T[P]
    }
    export{}

4.内置工具Record

作用：用于构造一个对象类型，他的所有的key都是keys类型，value都是Type类型 Record<keys,Type>.

    interface IKUN{
        name?:string
        age?:number
        slogan?:string
    }
    type t1 = "上海"|"北京"
//构造了新的对象类型 
    type IKUNs=Record<t1,IKUN>
    const ikun:IKUNs={
        "上海":{
            name:"bb",
            age:20,
        },
        "北京":{
            name:"aa",
            age:20,
        }
    }

    // 类型体操实现
    //首先我们需要明白一个知识点： type res = keyof any  -> string|number|symbol  通过这样可以获取联合类型
    // 确定Keys一定可以作为key的联合类型,因为 in 的是联合类型。
    type MyRecord<Keys extends keyof any,T> ={
        [P in  Keys]:T
    } 

5.内置工具Pick

作用：于构造一个类型，它是从Type类型中挑选一些属性keys

    interface IKUN{
        name?:string
        age?:number
        slogan?:string
    }
    type IKUNOptional =Pick<IKUN,'age'|'slogan'>

    // 类型体操 :关键点是保证 第二个类型是第一个的子类型
    type MyPick<T,K extends keyof T>={
        [P in K]:T[P]
    }
    type IKUNOptional1 =MyPick<IKUN,'age'|'slogan'>

6.内置工具Omit

作用：用于构造一个类型，它是从Type类型中过滤一些属性keys

    interface IKUN{
        name?:string
        age?:number
        slogan?:string
    }

    //
    type IKUNOptional =Omit<IKUN,'age'|'slogan'>

    // 类型体操
    type MyOmit<T,K extends keyof T>={
        //使用条件类型：因为要去除掉一些类型，所以当P是K的子类型是，需要返回never，否则返回P
        //此处我们需要明白什么是ts的分发类型：当在泛型中使用条件类型的时候，如果传入一个联合类型（P），就会变成分发的。
        [P in keyof T as P extends K? never:P]:T[P]
    }

7.内置工具Exclude

作用：用于构造一个类型，它是从UnionType联合类型中排除了所有可以赋值给ExcludeMembers的类型

    type IKUN = "唱"|"跳"|"RAP"

    // 
    type IKUNOptional =Exclude<IKUN,'唱'|'跳'>

    // 类型体操    分发 会依次执行判断T是否在E中，存在就返回never
    type MyExclude<T,E>= T extends E?never:T

8.内置工具Extract

作用：用于构造一个类型，它是从UnionType联合类型中提取了所有可以赋值给ExcludeMembers的类型

type IKUN = "唱"|"跳"|"RAP"

// 
type IKUNOptional =Extract<IKUN,'唱'|'跳'>

// 类型体操    分发 会依次执行判断T是否在E中,存在就返回T
type MyExtract<T,E>= T extends E?T:never

9.内置工具NonNullable

作用：NonNullable`<type>` 用于构造一个类型，这个类型从type中排除了所有的null、undefined类型

    type IKUN = "唱"|"跳"|"RAP"|null|undefined

    type IKUNOptional =NonNullable<IKUN>
    // 类型体操  
    type MyNonNullable<T>= T extends null|undefined ?never:T

10.内置工具 ReturnType/R

作用：获取函数的返回值类型

type CalcFnType = (num1: number, num2: number)=>number
function foo(){
    return "abc"
}

// 获取函数的返回值类型 :内置工具
type CalReturnType  = ReturnType<CalcFnType>
type FooReturnType = ReturnType<typeof foo>

// 类型体操题目：封装MyReturnType 
type MyReturnType<T extends (...args:any[])=>any> = T extends (...args:any[])=> infer R? R:never

11.内置工具InstanceType

作用： 用于构造一个由所有Type的构造函数的实例类型组成的类型

    class Person{}
    class Dog{}

    // typeof Person 构造函数的具体类型
    // InstanceType 构造函数创建出来的实例对象的类型
    type MyPerson = InstanceType<typeof Person>
    const p2:MyPerson = new Person()


    // 内置工具的使用：构造函数的例子
    function factory<T extends new (...args:any[]) => any >(ctor:T):InstanceType<T>{
        return  new ctor()
    }
    const p3 = factory(Person)

    // 类型体操
    type MyInstanceType<T extends new (...args:any[]) => any > = T extends new (...args:any[])=>infer R ? R:never