常见简单TypeScript类型

#TypeScript

实例

interface User {
    name: string,
    age: number
}

interface Student{
   age: string,
   id: number
}

交叉类型

type UserCross = User & Student

type UserCross = {
    name: string,
    age: never,  //交叉类型，相同key不同类型，合并后会成为never类型
    id: number
}

Partial可选类型

// 让对象属性的所有属性都是可选的 
type Partial<T> = { [P in keyof T] ? : T[P] }

type User = Partial<User>
    
type UserNotRequired = {
    name?: string,
    age?: number, 
}

Required必须类型

// 全部属性转为必需属性 
type Required<T> = { [P in keyof T]-?: T[k] }

type UserRequired = Required<User> //可选类型的反向效果

Readonly只读类型

// 全部属性转为只读属性 
type Readonly<T> = { readonly [P in keyof T]: T[P] }


type UserReadOnly = Readonly<User> 

type UserReadOnly = {
	readonly name: string,
    readonly age: number
}

Pick选择类型

// 获取对象类型中指定的某个属性
type Pick<T, K extends keyof T> = { [P in K]: T[P]; }

type UserPick = Pick<User,'age'>

type UserPick = {
 	age: number   
}

Record记录类型

// 将给定的类型或者对象类型赋给某个新的对象类型
type Record<K extends key of any, T> = { [P in K]: T; }

type UserRecord1 = Record<'test',User>
type UserRecord1 = {
   test: User
}

type UserRecord2 = Record<'test',Picke<User,'name'>>
type UserRecord2 = {
  test:{
    name: string
  }
}

type UserRecord3 = Record<'test',string>
type UserRecord3 = {
  test: string
}

Omit排除自身类型

// 排除对象类型自身中的某个属性，并赋给新的对象类型 
type Omit<T, K extends string | number | symbol> = { [P in Exclude<keyof T, K>]: T[P] }

type UserOmit = Omit<User,'age'>
type UserOmit = {
    name: string
}

Exclude排除类型

// 遍历T中的所有子类型，如果该子类型约束于U（存在于U、兼容于U），则返回never类型，否则返回该子类型
type Exclude<T, U> = T extends U ? never : T

// keyof User = 'name' | 'age'
type UserOmit =  Exclude<keyof User,'name'>
type UserOmit = 'age'