keyof 索引类型查询操作符

  • 索引类型查询操作符
  • 假设T是一个类型，那么keyof T产生的类型是T的属性名称字符串字面量类型构成的联合类型。
interface Infoss {
  name: string
  age: number
}
let infoProp: keyof Infoss
infoProp = 'name'
infoProp = 'age'

 [] 索引访问操作符 

const infoObj = {
  name: 'chen',
  age: 18
}
const Infoss = infoObj['name'] // 访问接口infoObj的name属性,返回该类型

映射类型

lib 库中的五个高级映射类型

Partial: 接口类型中的属性转换为可选 

interface Message {
  age: number
  name: string
  sex: string
}
type ReadOnlyMsg1 = Partial<Message>
type ReadOnlyMsg2 = Readonly<Message>
let message: ReadOnlyMsg1 = {
  age: 18,
  name: 'chen',
  sex: 'nv'
}

Readonly: 接口类型中的属性转换为可读

Pick 从T中选取一组属性K 

type person5 = Pick<Person, "name">;
// person5 === {name: string}

Record <K extends keyof any, T> 将T类型分配给K属性

type person6 = Record<'name' | 'age', string>
// person6 === {name: string; age: string}

unknown 

// 1. 任何类型的值都可赋值给unknown类型
let value1: unknown
value1 = 1
value1 = '123'

// 2. 如果没有类型断言或者基于控制流的类型细化时，unknown不可赋值给其他类型
// 此时只能赋值给unknown和any

let value2: unknown
// let value3: string = value2

// 3. 如果没有类型断言或者基于控制流的类型细化时，不能在它上面进行任何计算操作
let value4: unknown
// value4 += 1

// 4. unknown与任何其他类型组成的交叉类型，最后都等于其他类型
type types1 = string & unknown

// 5. unknown与任何其他类型（除了any）组成的联合类型，都等于unknown
type types2 = unknown | string // unknown
type types3 = unknown | any // any

// 6. never类型是unknown类型的子类型
type types4 = never extends unknown ? true : false // true

// 7. keyof unknown 等于类型never
type types5 = keyof unknown // never

// 8. 只能对unknown进行等或不等操作，不能进行其他操作
console.log(value1 === value2)

// 9. unknown 不能访问它的属性，作为函数调用和作为类创建实例
// 10.使用映射类型时，如果遍历的是unknown时，则不会映射任何属性
type Types1<T> = {
  [P in keyof T]: number
}
type types6 = Types1<any>
type types7 = Types1<unknown>

条件类型

  • 使用三目运算符判断类型
type Types2<T> = T extends string ? number : string
let index1: Types2<'a'>
// 分布式条件类型
type typeName<T> = T extends any ? T : never
type Types3 = typeName<string | number>

type TypeNames1<T> = T extends string
  ? string
  : T extends number
  ? number
  : T extends boolean
  ? boolean
  : T extends undefined
  ? undefined
  : T extends () => void
  ? () => void
  : object
type Types4 = TypeNames1<() => void>

type Diff<T, U> = T extends U ? never : T
type Types5 = Diff<string | number | boolean, undefined | number>

infer  条件类型推断 

type Type9<T> = T extends [infer U] ? U : T
type Test99 = Type9<string[]> //type Test99 = string[]

Exclude

  • Exclude <T,U> 返回T中不包含U的的类型 
type Type10 = Exclude<'a' | 'b' | 'c', 'b'>

Extract

  • Extract<T,U> 返回T中可以赋值给U的类型
type Type11 = Extract<'a' | 'b' | 'c', 'b' | 'c'>

NonNullable<T> 去除null  undefined 

type Type12 = NonNullable<string | null | undefined>//type Type12 = string

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

type Type13 = ReturnType<() => string> // type Type13 = string

InstanceType 获取实例类型 

class Acc {}
type Instan1 = InstanceType<typeof Acc>
type Instan2 = InstanceType<any>
type Instan3 = InstanceType<never>
// type Instan4 = InstanceType<string>
赏

爬。