TypeScript常用的内置工具

Partial

可以让类型中的所有属性都变成可选属性

​
//定义一个类型
// type aType = { id: number, name: string, age: number, hobby?: string[] }
//定义一个变量
const user1: aType = { id: 1, name: 'Tom', age: 18 }
//使用Partial 
 const user2: Partial<aType> = { name: 'Jack' }  // 此时user2中的属性都是可选属性

Require

让所有的类型中的可选属性变成必选属性

// 使用Require定义类型
//定义一个类型
type aType = { id: number, name: string, age: number, hobby?: string[] }
//定义一个变量
//这样会有语法报错，因为类型 "{ id: number; name: string; age: number; }" 中缺少属性 "hobby"，但类型 "Required<aType>" 中需要该属
// const user3: Required<aType> = { id: 1, name: 'Tom', age: 18 }
//需要把所有的属性都添加上才可以
const user4: Required<aType> = { id: 1, name: 'Tom', age: 18, hobby: ['football', 'basketball'] }

Pick

可以选择需要的字段属性

​
// Pick 可以从一个类型中选择需要的字段属性
//定义一个类型
type aType = { id: number, name: string, age: number, hobby?: string[] }
//表示从aType中选择name和age两个属性
const user5: Pick<aType, 'name' | 'age'> = { name: 'Tom', age: 18 }
//会有语法报错， 并没有从aType中选择id属性，此时user5中只有name和age两个属性
// const user6 : Pick<aType, 'name' | 'age'> = {id :1 ,  name: 'Tom', age: 18 }

Omit

可以选择不需要的字段属性

//Omit 可以从一个类型中删除不需要的字段属性
//定义一个类型
type aType = { id: number, name: string, age: number, hobby?: string[] }
//定义一个变量
const user1: aType = { id: 1, name: 'Tom', age: 18 }
//使用Omit , user2的类型为{ name: string, age: number } ， 剔除id属性
const user2: Omit<aType, 'id'> = { name: 'Jack', age: 18 }
//会有语法报错，user2类型中没有id属性
// const user2: Omit<aType, 'id'> = {id：1 , name: 'Jack', age: 18 }

Exclude

将一个类型从一个联合类型中排除

​
//Exclude : 将一个类型从联合类型中排除
//定义一个联合类型
type aType = string | number | boolean | null | undefined
//定义一个变量
let query: aType = 1
query = 'hello'
query = true
query = null
query = undefined
​
//使用Exclude 定义一个联合类型 排除null和undefined
type bType = Exclude<aType, null | undefined>
//定义一个变量
// let query1: Exclude<aType, null | undefined> = 1
let query1: bType = 1
query1 = 'hello'
query1 = true
//此时给query1赋值为null和undefined都会报错
// query1 = null
// query1 = undefined

Extract

将一个类型从联合类型中提取

​
//Extract : 将一个类型从联合类型中提取
//定义一个联合类型
type aType = string | number | boolean | null | undefined
//定义一个变量
let query: aType = 1
query = 'hello'
query = true
query = null
query = undefined
​
// 使用Extract 定义一个联合类型 提取string类型
type bType = Extract<aType, string>
//定义一个变量, 此时只能给query1赋值为string类型
// let query1: Extract<aType, string> = 'hello'
let query1: bType = 'hello'
/* 赋值为其他类型会报错
query1 = 1
query1 = true
query1 = null
query1 = undefined */

NonNullable

去除联合类型中的null 和 undefined

//NonNullable : 将一个联合类型的null和undefined都变成never , 就是联合中剔除了null和undefined
//定义一个联合类型
type aType = string | number | boolean | null | undefined
//定义一个变量
let query: aType = 1
query = 'hello'
query = true
query = null
query = undefined
//使用NonNullable 定义一个联合类型 提取string类型
type bType = NonNullable<aType>   //bType = string| number | boolean
//定义一个变量
// let query1: NonNullable<aType> = 'hello'
let query1: bType = 'hello'
query1 = 1
query1 = true
//赋值为null和undefined都会报错
// query1 = null
// query1 = undefined

ReturnType

可以获取返回值的类型

//定义一个函数
function fun () {
    return 1
}
//定义一个变量
//表示 let query : number = 1
let query: ReturnType<typeof fun> = 1

Record

将一个类型映射到另一个类型的值

//Record 将一个类型的值映射到另一个类型的值
//定义一个类型
//表示数据中可以为任意类型
type aType = { [prop: string]: any }
//定义一个变量
let query: aType = { id: 1, name: 'Tom', age: 18 }
​
// 使用Record 定义一个类型
type bType = Record<string, any> // 这句所表示的意思就是 bType = {[prop: string]: any}
//定义一个变量
let query1: bType = { id: 1, name: 'Tom', age: 18 }
​
interface User {
    id: number
    name: string
    age: number
}
// 定义一个联合类型
type UserType = 'JS' | 'TS'
//定义一个变量, 此时的变量包含的属性为JS和TS ， JS和TS都是User类型
let user: Record<UserType, User> = {  
    JS: { id: 1, name: 'Tom', age: 18 },
    TS: { id: 2, name: 'Jack', age: 19 }
}