Typescript中的工具类型

keyof

keyof可以用于获取某种类型的所有键，其返回值类型为联合类型(string | number | …)，其可以作用域普通对象，索引签名，枚举类型等等。

例子：

// 例1：
// 此时K 会遍历 T对象中的key值，并且限制输入obj中不存在的键
function getKey<T extends object, K extends keyof T>(obj: T, key: K) {
    return obj[key]
}

interface Person {
    name: string;
    age: number;
}

const person: Person = {
    name: '',
    age: 1
}

console.log('name', getKey(person, 'name'))

console.log('name', getKey(person, 'height'))// error。因为person中不存在height属性

// 例2：
interface Person {
    name: string;
    age: number;
}

type PKey = keyof Person

const name: PKey = 'name' // 变量name只能赋值为name|age

extends

extends主要是用于其他继承其他接口的属性，因此我们可以在开发过程中定义一个公共的父级接口，再定义多个子级接口去拓展父级接口具有的公共属性。

例子：

interface Biology {
    age: number;
}

interface Person extends Biology {
    name: string;
}

const person: Person = {
    name: 'liu',
    age: 11,
}

Partial

当我们对于对象内的属性不确定时，我们会将对应的属性加入可选符?，如果对于整个对象内的属性都不确定，我们可以通过Partial解决，Partial可以将其类型中的所有属性都变为可选。

interface Person {
    name: string;
    age: number;
    height:number;
    weight?:number;
}
// 此时 Person中的属性都是可选的
const person: Partial<Person> = {
    name: 'liu'
}

Required

和Partial相反，生成一个新类型，该类型与 T 拥有相同的属性，但是所有属性皆为必选项。

interface Foo {
    name: string
    age?: number
}
type Bar = Required<Foo>

// 相当于
type Bar = {
    name: string
    age: string
}
// error age为必选项
const bar:Bar = {
    name: 'wang'
}

Record

Record作用是将K中所有联合类型的子类型转换为T类型。

// 例1
interface Person {
    name: string;
    age: number
}

type Ktype = 'father' | 'son'

const person: Record<Ktype, Person> = {
    father: {
        name: 'liu',
        age: 7
    },
    son: {
        name: 'liu',
        age: 20
    }
}

// 例2
type Recordable<T = any> = Record<string, T>;
const obj:Recordable<any> = {
    a:123,
    b:332,
    c:[]
}

Readonly

Readonly的作用是将类型中所有的属性都增加readonly修饰符，变为只读。

interface Person {
    name: string;
    age: number;
}
const person: Readonly<Person> = {
    name: 'liu',
    age: 18
}

// error 此时person内的属性都是只读的
person.age = 10

Pick

Pick的作用是将类型中的属性挑出来，重新组成一个新的类型。

interface Person {
    name: string;
    age: number;
    height: number;
}

type NewPerson = Pick<Person, 'name' | 'age'>
	
const person:NewPerson = {
    name: 'liu',
    age: 18
}

Omit

 Omit使用语法为:Omit<T,K>，其作用是将T中存在的K类型剔除。

interface Person {
    name: string;
    age: number;
    height: number;
}

type OmitTest = Omit<Person, 'height'>

const person: OmitTest = {
    name: 'name',
    age: 11
}

Exclude

Exclude<T, U>，提取U在B中没有的属性。

type A = number | string | boolean
type B = number | boolean

type Foo = Exclude<A, B>
// 相当于
type Foo = string

Extract

Extract<T, U>，和Exclude相反。

type A = number | string | boolean
type B = number | boolean

type Foo = Exclude<A, B>
// 相当于
type Foo = number | boolean

NonNullable

NonNullable<T>，过滤类型中的 null 及 undefined 类型。

type T0 = NonNullable<string | number | undefined>; //  string | number

type T1 = NonNullable<string[] | null | undefined>; // string[]

Parameters

Parameters<T>，T为函数类型，获取函数的参数类型组成元组

declare function f1(arg: { a: number; b: string }): void;

type T0 = Parameters<() => string>; // []

type T1 = Parameters<(s: string) => void>; // string

type T2 = Parameters<<T>(arg: T) => T>; //  [arg: unknown]

type T3 = Parameters<any>; // unknown[]

type T3 = Parameters<never>; // never

ReturnType

ReturnType<T>，获取函数的返回值类型

type T0 = ReturnType<() => string>; // string

type T1 = ReturnType<(s: string) => void>; // void

type T2 = ReturnType<<T>() => T>; // unknown

type T3 = ReturnType<<T extends U, U extends number[]>() => T>; // number[]