常用ts类型

联合类型

1. Exclude<T, U> - 从类型T中排除类型U的类型

type T = number|string
type U = Exclude<T, string> // number

2. Extract<T, U> - 从类型T中提取类型U的类型

type T = number | string
type U = Extract<T, string> // string

3. NonNullable<T> - 从类型T中排除null和undefined类型

type T = string | null | undefined
type U = NonNullable<T> // string

函数类型工具

1. Parameters<T> - 获取函数T的参数类型

type T = (a: number, b: string) => void
type U = Parameters<T> // [number, string]

2. ReturnType<T> - 获取函数T的返回类型

type T = (a: number, b: string) => void
type U = ReturnType<T> // void

3. ConstructorParameters<T> - 获取构造函数T的参数类型

type T = new (a: number, b: string) => void
type U = ConstructorParameters<T> // [number, string]

4. InstanceType<T> - 获取构造函数T的实例类型

type T = new (a: number, b: string) => void
type U = InstanceType<T> // { a: number; b: string; }

基础类型扩展

Keyof<T> - 获取类型T的所有键名

declare type Keyof<T> = T extends any ? keyof T : never;
type T = { a: number; b: string; }
type U = Keyof<T> // "a" | "b"

Awaitable<T> - 表示类型T可能是一个可等待的值

declare type Awaitable<T> = T | Promise<T>| Awaitable<T>;
type T = Promise<number>
type U = Awaitable<T> // number

Arrayable<T> - 表示类型T可能是一个数组或单个值

declare type Arrayable<T> = T | T[];
type T = number | number[]
type U = Arrayable<T> // number | number[]

ElementType<T> - 获取数组T的元素类型

declare type ElementType<T> = T extends (infer U)[] ? U : T;
type T = number[]
type U = ElementType<T> // number

toArray<T> - 将类型T转换为数组类型

declare type toArray<T> = T extends any? T[] : never;
type T = number
type U = toArray<T> // number[]

ArgumentType<T> - 获取函数T的参数类型

declare type ArgumentType<T> = T extends (...args: infer U) => any? U : never;
type T = (a: number, b: string) => void
type U = ArgumentType<T> // [number, string]

Shift<T> - 获取元组T的第一个元素类型

declare type Shift<T> = T extends [any, ...infer U]? U : never;
type T = [number, string]
type U = Shift<T> // [string]

Pop<T> - 获取元组T的最后一个元素类型

declare type Pop<T> = T extends [...infer U, any]? U : never;
type T = [number, string]
type U = Pop<T> // [number]

Push<T, U> - 将类型U添加到元组T的末尾

declare type Push<T, U> = [...T, U];
type T = [number, string]
type U = Push<T, boolean> // [number, string, boolean]

Unshift<T, U> - 将类型U添加到元组T的开头

declare type Unshift<T, U> = [U, ...T];
type T = [number, string]
type U = Unshift<T, boolean> // [boolean, number, string]

ObjectEntries<T> - 获取对象T的键值对类型

declare type ObjectEntries<T> = T extends object? { [K in keyof T]: [K, T[K]] }[keyof T] : never;
type T = { a: number; b: string; }
type U = ObjectEntries<T> // ["a", number] | ["b", string]

ObjectFromEntries<T> - 将键值对类型T转换为对象类型

declare type ObjectFromEntries<T> = T extends [infer K, infer V]? { [K in K]: V } : never;
type T = ["a", number] | ["b", string]
type U = ObjectFromEntries<T> // { a: number; b: string; }

进阶扩展

AssertEqual<T, U> - 检查类型T是否与类型U相等

declare type AssertEqual<T, U> = T extends U? U extends T? true : false : false;
type T = { a: number; b: string; }
type U = { a: number; b: string; }

DeepPartial<T> - 递归地将类型T的所有属性变为可选

declare type DeepPartial<T> = T extends object? { [K in keyof T]?: DeepPartial<T[K]> } : T;
type T = { a: number; b: { c: string; }; }
type U = DeepPartial<T> // { a?: number; b?: { c?: string; }; }

PartialByKeys<T, K> - 将类型T的指定键K变为可选

declare type PartialByKeys<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
type T = { a: number; b: string; }
type U = PartialByKeys<T, "a"> // { a?: number; b: string; }

RequiredByKeys<T, K> - 将类型T的指定键K变为必选

declare type RequiredByKeys<T, K extends keyof T> = Omit<T, K> & Required<Pick<T, K>>;
type T = { a?: number; b: string; }
type U = RequiredByKeys<T, "a"> // { a: number; b: string; }

高级函数工具

FunctionKeysObject<T> - 提取对象中所有函数类型的属性

declare type FunctionKeysObject<T> = { [K in keyof T]: T[K] extends Function? K : never }[keyof T];
type T = { a: number; b: () => void; c: string; }
type U = FunctionKeysObject<T> // "b"

FunctionMapType<T> - 创建类型函数的函数事件系统

declare type FunctionMapType<F> = <T extends keyof FunctionKeysObject<F>>(key: T, ...args: F<T> extends ((...args: infer P) => any) ? P : never[]) => void;

interface EventFunctions {
    a(): void

    b(params: { c: string, d: number }): void
}

declare const emit = FunctionMapType<EventFunction>

emit('a')
emit('b', {c: 'hello', d: 1})