操作符

获取类型的键值 keyof

返回一个type 的所有属性组成的联合类型

type Person = {
    name: string 
  age: number
}
type properties = keyof Person // 'name'|'number'

获取变量类型 typeof

const obj = {
  name: 'jacob',
  age: 23
}
type t = typeof obj
// type t = {name: string; age: number}

遍历联合类型 in

使用in 遍历联合类型，作为对象 key 值的类型

type Courses = price|time
type CourseObj = {
    [k in Courses]:number // 遍历Courses类型作为key
}

泛型

基本使用

// 普通类型定义
type Dog<T> = { name: string, type: T }
// 普通类型使用
const dog: Dog<number> = { name: 'ww', type: 20 }
// 类定义
class Cat<T> {
  private type: T;
  constructor(type: T) { this.type = type; }
}
// 类使用
const cat: Cat<number> = new Cat<number>(20); // 或简写 const cat = new Cat(20)
// 函数定义
function swipe<T, U>(value: [T, U]): [U, T] {
  return [value[1], value[0]];
}
// 函数使用
swipe<Cat<number>, Dog<number>>([cat, dog])  // 或简写 swipe([cat, dog])

推导和默认值

type Dog<T> = { name: string, type: T }
function adopt<T>(dog: Dog<T>) { return dog };
const dog = { name: 'ww', type: 'hsq' };  // 这里按照Dog类型的定义一个type为string的对象
adopt(dog);  // Pass: 函数会根据入参类型推断出T为string
type Dog<T = string> = { name: string, type: T }

extends进行类型约束和三元运算

// 限定 T 继承 number
function sum<T extends number>(value: T[]): number {
  let count = 0;
  value.forEach(v => count += v);
  return count;
}
type ExtendsType<T> = T extends boolean ? "重学前端" : "玩转Vue3"

infer 推断

使用 infer 修饰推断出的类型，一般在泛型中使用，对满足条件的泛型类型进行类型抽取

// infer 实现 ReturnType
type ReturnType1<T> = T extends ()=>infer P ? P:never 
type Foo = () => number
type Foo1 = ReturnType1<Foo> // number

泛型工具

Partial

Partial<T>，将泛型T的属性都变成可选，返回的属性是 T 的子集

type Person = {
    name: string 
  age: number
}
type particalPerxon = Partial<Person>
// 相当于 type particalPerxon = {name?:string; age?:number}
const Jack:Partical<Person> = {name: 'Jack'}

// 实现 Partial<T>
type Partial<T> = {
  [P in keyof T]? : T[P]
}

Required（与 Partial 相反）

Required<T>，将泛型 T 的所有属性都变成必须

type Person = {
    name?: string 
  age?: number
}
const Jack:Required<Person> = {
    name: 'Jack',
  age: 23
}

// 实现 Required<T>
type Required<T> = {
  [P in keyof T]: T[P]
}

Pick

Pick<T, a | b>，保留泛型T中的某些属性，保留的属性由第二个参数决定，可以但是单个属性，也可以是联合类型

type Person = {
    name: string 
  age: number
  location:string
}
const Jack:Pick<Person, 'name'|'age'> = {
    name: 'Jack'
  age:23
}

// 实现 Pick<T, K>
type Pick<T, K extends keyof T> = { // extends 泛型约束
  [P in K]: T[P]
}

Omit(与 Pick 相反)

Omit<T,K>，将泛型T中的K（string）属性删除，保留剩余属性

type Person = {
    name: string 
  age: number
}
const Jack:Omit<Person, 'age'> = {name: 'Jack'}

// 实现 Omit<T, K>, 借助了 Exclude, Pick
type Omit<T,K> = Pick<T, Exclude<keyof T, K>>

Parameters

Parameters<T>， 传入的泛型T必须是个函数类型，返回函数参数类型组成的元组

type fn = (name:string, age:number) => void
type params = Parameters<fn> // [string, number]

// 实现 Parameters
type Parameters<T> = T extends (param: infer P)=> any ? P : never

ReturnType

ReturnType<T>，传入的泛型T必须是函数类型，返回函数类型 T 返回值的类型

const fn = () => {
    return {
       name: 'jack',
    age: 23
  }
}
// 用 typeof 获取函数fn的类型
type res = ReturnType<typeof fn> // {name:string; age:number}

// 实现 ReturnType<T>
type ReturnType<T> = T extends ()=> infer P ? P: never

Exclude

Exclude<T, K>，其中T必须是联合类型，从T中排除K(字符串)

type Person = {
    name: string 
  age: number
}
type keys = keyof Person
type age = Exclude<keys, 'name'> // age

// 实现 Exclude<T, K>
type Exclude<T, K> = T extends K ? never: T

Extract

Extract<T, K>，T和K 都是联合类型， 抽取两者的交集

type A = number | string | boolean
type B = number | boolean
type Foo = Extract<A, B> // number | boolean

// 实现 Extract<T, K>
type Extract<T, K> = T extends K ? T :never