typescript中的高级类型

typescript中的高级类型

Partial

将一个类型所有参数转换为可选

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

type Man {
	sex:string,
	age:number
}
type ManPartial  = Partial<Man> 
// 这样我们就可以在后续中使用空对象定义一个带有类型的值
let obj:ManPartial | any = {}

Exclude

取出T中除了U以外的，即取出T有U没有的

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

// 这样我们用来取T在U内还少了什么
type Test = Exclude<1 | 2 | 3 ,2 | 5> // 返回1，3

Extract

取出T,U的交集

type Extract<T,U> = T extends U ? T: never
type Test = Exclude<1 | 2 | 3 ,2 | 5> // 返回2

ReturnType

返回值类型

type ReturnType<T> = T extends (
  ...args: any[]
) => infer R
  ? R
  : any;

type test = ReturnType<()=>voild> // void

// inter定义一个未知类型
const obj = {
	man: {
        house:'大别墅',
        car:'小汽车'
    },
    otherproperty:'xxxxx'
}
// 如果要定义obj的类型，并且想要获取man的类型
type insideMan = T extends {man: infer R}? R:any
// insideMan就是man对应对象的类型

Pick

选取类型

type Pick<T,K extends of T> = {
	[P in k]:T[P]          
}
type User {
	name:string,
	age:number,
	address:string
}
type test = Pick<User,'age' | 'address'> // age,address

Record

为类型的值添加类型

type Record<K extends of any,T> = {
 	[P in k]:T           
 }
type man = 'age' | 'name' | 'home'
type test = Record<man,{value:string}>
/* type test = {
      age: {
          value: string
      };
      name: {
          value: string
      };
      home: {
          value: string
      };
}*/

Omit

去除类型

type Omit<T,K extends of any> = Pick<T,Exclude<keyof T,	K>>
type User {
	name:string,
	age:number,
	address:string
}
type test = Omit<User,'name'> // 'age' | 'address'

NonNullable

去除空值

type NonNullable<T> = T extends null | undefined ? never : T;

type t = NonNullable<'name' | undefined | null>;
/* type t = 'name' */