工具类型

可选泛型

表示泛型内的属性不是必须的

const info1:Partial<Props>={
  name:'1'
}

必选泛型

和可选相反，使用Required关键字

转化泛型

将T中的所有属性 转化为K类型

 interface Props {
        name: string,
        age: number
    }
    type InfoProps = 'JS' | 'TS'
    const Info: Record<InfoProps, Props> = {
        JS: {
            name: '小杜杜',
            age: 7
        },
        TS: {
            name: 'TypeScript',
            age: 11
        }
    }

采集泛型

将某个类型的子属性挑选出来变成包含这个挑选部分的类型

Pick 通常用来返回一个新的type

他是采集T中一部分属性 作为新的类型使用

 interface Props {
        name: string,
        age: number,
        sex: boolean
    }
    type nameProps = Pick<Props, 'name' | 'age'>
    const info: nameProps = {
        name: '小杜杜',
        age: 7
    }

剔除泛型

将T类型中的U类型移除, 注意U中如果有 T没有的属性， 那么结果将会是never

  // 数字类型
    type numProps = Exclude<1 | 2 | 3, 1 | 2> // 3
    type numProps1 = Exclude<1, 1 | 2> // nerver
    type numProps2 = Exclude<1, 1> // nerver
    type numProps3 = Exclude<1 | 2, 7> // 1 2
    // 字符串类型
    type info = "name" | "age" | "sex"
    type info1 = "name" | "age" 
    type infoProps = Exclude<info, info1> //  "sex"
    // 类型
    type typeProps = Exclude<string | number | (() => void), Function> // string | number
    // 对象
    type obj = { name: 1, sex: true }
    type obj1 = { name: 1 }
    type objProps = Exclude<obj, obj1> // nerver

提取泛型

 type numProps = Extract<1 | 2 | 3, 1 | 2> // 1 | 2

移除泛型

将已经声明的类型进行属性剔除后获得新类型，和Exclude类似，不同的是它是返回一个新类型

Omit， 在原有的类型上剔除一部分类型返回一个新类型

非空泛型

从T中 排序 null 和 undefined

type Props = NonNullable<string|number|undefined> // string|number

获取函数泛型

用于获取 函数T 的返回的类型

type Props = ReturnType<() => string> // string
    type Props1 = ReturnType<<T extends U, U extends number>() => T>; // number
    type Props2 = ReturnType<any>; // any
    type Props3 = ReturnType<never>; // any

获取参数泛型

获取 函数T中的参数类型

type Props = Parameters<() => string> // []
    type Props1 = Parameters<(data: string) => void> // [string]
    type Props2 = Parameters<any>; // unknown[]
    type Props3 = Parameters<never>; // neve

获取 实例

class C {
  x = 0;
  y = 0;
}
type T0 = InstanceType<typeof C>;
// type T0 = C
type T1 = InstanceType<any>;
// type T1 = any
type T2 = InstanceType<never>;
// type T2 = never
type T3 = InstanceType<string>;
// TypeError: Type 'string' does not satisfy the constraint 'abstract new (...args: any) => any'.
// type T3 = any
type T4 = InstanceType<Function>;
// TypeError: Type 'Function' does not satisfy the constraint 'abstract new (...args: any) => any'. Type 'Function' provides no match for the signature 'new (...args: any): any'.
// type T4 = any