xjq blog | xjq blog

概念

TypeScript 是一种由微软开发的自由和开源的编程语言。它是 JavaScript 的一个超集，而且本质上向这个语言添加了可选的静态类型和基于类的面向对象编程

优势

解决大型项目的稳定性, 可维护性
强类型, 支持静态和动态类型
编译期间发现错误

基础类型

boolean
number
string
undefined
null

undefined 和 null 默认是所有类型的子类型

指定 strictNullChecks 之后, 只能只能赋值给自己和 void

any
unknown

安全类型, 类似 any, unknown 类型无法赋值给其他类型变量

void
never

永远不存在的类型

程序无法运行到(异常)

symbol
数组类型
元组类型

函数类型

interface

interface 是 TS 设计出来用于定义对象类型的，可以对对象的形状进行描述

可选属性

readonly 只读属性

自定义属性(可索引的类型)

类

枚举

高级类型

联合类型

交叉类型

类型别名

与 interface 对比

相同点

都可以定义一个对象或函数

都允许继承, interface 使用 extends,type 使用交叉类型实现继承

区别

类型别名用于给各种类型定义别名, 更加简洁

type 可以声明基本类型, 联合类型, 交叉类型, 元组, interface 不行

interface 可以合并重复声明

索引类型

keyof 取某个类型的键, 返回联合类型

泛型约束

extends, 约束泛型变量

映射类型

in

对联合类型遍历

泛型

软件工程中，我们不仅要创建一致的定义良好的 API，同时也要考虑可重用性。组件不仅能够支持当前的数据类型，同时也能支持未来的数据类型，这在创建大型系统时为你提供了十分灵活的功能

体操

Await

type MyAwaited<T> = T extends Promise<infer K> ? (K extends Promise<unknown> ? MyAwaited<K> : K) : T

Pick

type MyPick<T, K extends keyof T> = { [P in K]: T[P] }

Exclude

type MyExclude<T, K extends T> = T extends K ? never : T

First

type First<T extends unknown[]> = T extends [infer P, ...unknown[]] ? P : never

Readonly

type MyReadonly<T> = { readonly [K in keyof T]: T[K] }

IF

type If<C extends boolean, T, F> = C extends true ? T : F

Concat

type Concat<T extends unknown[], U extends unknown[]> = [...T, ...U]

Push

type Push<T extends unknown[], U> = [...T, U]

Includes

type Includes<T extends unknown[], U> = T extends [infer P, ...infer K]
  ? Equal<P, U> extends true
    ? true
    : Includes<K, U>
  : false

Equal

type Equal<P, U> = (<T>() => T extends P ? 1 : 2) extends <T>() => T extends U ? 1 : 2 ? true : false

Unshift

type Unshift<T extends unknown[], U> = [U, ...T]

Parameters

type MyParameters<T extends (...args: any[]) => any> = T extends (...args: infer K) => any ? K : never

Readonly2

type MyReadonly2<T, K extends keyof T = keyof T> = { readonly [R in keyof T]: T[R] } & {
  [R in Exclude<keyof T, K>]: T[R]
}

Chainable

type Chainable<T = {}> = {
  option: <K extends string, V>(
    key: K extends keyof T ? (V extends T[K] ? never : K) : K,
    value: V
  ) => Chainable<Omit<T, K> & { [P in K]: V }>
  get: () => T
}

DeepReadonly

type DeepReadonly<T> = T extends Object
  ? {
      readonly [R in keyof T]: T[R] extends Object
        ? T[R] extends Function
          ? T[R]
          : DeepReadonly<T[R]>
        : Readonly<T[R]>
    }
  : never

TupleToUnion

type TupleToUnion<T extends unknown[]> = T[number]

Last

type Last<T extends unknown[]> = T extends [...unknown[], infer R] ? R : T[0]

PromiseAll

declare function PromiseAll<T extends unknown[]>(
  values: readonly [...T]
): Promise<{ [R in keyof T]: T[R] extends Promise<infer P> ? Awaited<P> : T[R] }>

Lookup

type Lookup<U, T extends string> = U extends { type: T } ? U : never

Capitalize

type MyCapitalize<S extends string> = S extends `${infer P}${infer R}` ? `${Uppercase<P>}${R}` : S

// 1 ways
type UpperLetter =
  | 'A'
  | 'B'
  | 'C'
  | 'D'
  | 'E'
  | 'F'
  | 'G'
  | 'H'
  | 'I'
  | 'J'
  | 'K'
  | 'L'
  | 'M'
  | 'N'
  | 'O'
  | 'P'
  | 'Q'
  | 'R'
  | 'S'
  | 'T'
  | 'U'
  | 'V'
  | 'W'
  | 'X'
  | 'Y'
  | 'Z'

type KebabCase<S extends string, U = S> = S extends `${infer R}${infer P}`
  ? R extends UpperLetter
    ? U extends `${infer _}${infer US}`
      ? P extends US
        ? `${Lowercase<R>}${KebabCase<P, S>}`
        : `-${Lowercase<R>}${KebabCase<P, S>}`
      : S
    : `${R}${KebabCase<P, S>}`
  : S

// 2 ways
type KebabCase<S extends string> = S extends `${infer R}${infer P}`
  ? P extends Uncapitalize<P>
    ? `${Lowercase<R>}${KebabCase<P>}`
    : `${Lowercase<R>}-${KebabCase<P>}`
  : S

AnyOf

// 1 way
type AnyOf<T extends unknown[]> = T extends [infer R, ...infer P]
  ? R extends [] | '' | false | 0 | Record<string, never>
    ? AnyOf<P>
    : true
  : false

// 2 way
type AnyOf<T extends any[]> = T[number] extends 0 | '' | false | [] | { [key: string]: never } ? false : true

IsNever

type IsNever<T> = [T] extends [never] ? true : false

Replace

type Replace<S extends string, From extends string, To extends string> = From extends ''
  ? S
  : S extends `${infer R}${From}${infer P}`
  ? `${R}${To}${P}`
  : S

ReplaceAll

type ReplaceAll<S extends string, From extends string, To extends string> = From extends ''
  ? S
  : S extends `${infer R}${From}${infer P}`
  ? `${ReplaceAll<R, From, To>}${To}${ReplaceAll<P, From, To>}`
  : S

Parameters

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

Flatten

type Flatten<T extends unknown[]> = T extends [infer R, ...infer P]
  ? R extends unknown[]
    ? [...Flatten<R>, ...Flatten<P>]
    : [R, ...Flatten<P>]
  : []

Absolute

type Absolute<T extends number | string | bigint> = `${T}` extends `-${infer R}` ? R : `${T}`

IsUnion

type IsUnion<T, P = T> = [T] extends [never] ? false : T extends P ? ([P] extends [T] ? false : true) : false

ReplaceKeys

type ReplaceKeys<U, T, Y> = U extends U
  ? { [R in keyof U]: R extends T ? (R extends keyof Y ? Y[R] : never) : U[R] }
  : never

PickByType

type PickByType<T, U> = { [R in keyof T as T[R] extends U ? R : never]: T[R] }

OmitByType

type OmitByType<T, U> = { [R in keyof T as T[R] extends U ? never : R]: T[R] }

StartsWith

type StartsWith<T extends string, U extends string> = T extends `${U}${infer _}` ? true : false

EndsWith

type EndsWith<T extends string, U extends string> = T extends `${infer _}${U}` ? true : false

PartialByKeys

type Merge<T> = {
  [Key in keyof T]: T[Key]
}
type PartialByKeys<T, K = keyof T> = Merge<
  { [R in keyof T as R extends K ? never : R]: T[R] } & { [R in keyof T as R extends K ? R : never]?: T[R] }
>

RequiredByKeys

type Merge<T> = { [R in keyof T]: T[R] }
type RequiredByKeys<T, K = keyof T> = Merge<
  { [R in keyof T as R extends K ? never : R]: T[R] } & { [R in keyof T as R extends K ? R : never]-?: T[R] }
>

IndexOf

type IndexOf<T, U, Res extends unknown[] = []> = T extends [infer P, ...infer R]
  ? Equal<U, P> extends true
    ? Res['length']
    : IndexOf<R, U, [...Res, P]>
  : -1

LastIndexOf

type LastIndexOf<T extends unknown[], U> = T extends [...infer R, infer P]
  ? Equal<P, U> extends true
    ? R['length']
    : LastIndexOf<R, U>
  : -1

Unique

type IndexOf<T, U, Res extends unknown[] = []> = T extends [infer P, ...infer R]
  ? Equal<U, P> extends true
    ? Res['length']
    : IndexOf<R, U, [...Res, P]>
  : -1

type Unique<T, Res extends unknown[] = []> = T extends [infer P, ...infer R]
  ? IndexOf<Res, P> extends -1
    ? Unique<R, [...Res, P]>
    : Unique<R, Res>
  : Res

MapTypes

type Include<T, U> = T extends { mapFrom: any; mapTo: any }
  ? Equal<T['mapFrom'], U> extends true
    ? T['mapTo']
    : never
  : never

type MapTypes<T, R extends { mapFrom: any; mapTo: any } | { mapFrom: any; mapTo: any }> = {
  [P in keyof T]: Include<R, T[P]> extends never ? T[P] : Include<R, T[P]>

Shift

type Shift<T> = T extends [infer _, ...infer R] ? R : never

Reverse

type Reverse<T> = T extends [...infer R, infer K] ? [K, ...Reverse<R>] : []

TupleToNestedObject

type TupleToNestedObject<T, U> = T extends [infer R, ...infer Rest]
  ? R extends string
    ? { [K in R]: TupleToNestedObject<Rest, U> }
    : U
  : U

FlipArguments

type Reverse<T> = T extends [...infer R, infer K] ? [K, ...Reverse<R>] : []
type FlipArguments<T extends (...args: any) => any> = T extends (...args: infer R) => infer P
  ? (...args: Reverse<R>) => P
  : never

Flip

type Flip<T extends Record<string | number | symbol, any>> = {
  [R in keyof T as T[R] extends boolean ? `${T[R]}` : R extends string | number | symbol ? T[R] : never]: R
}

Subsequence

type Subsequence<T extends any[]> = T extends [infer P, ...infer R] ? [...Subsequence<R>] | [P, ...Subsequence<R>] : []

Without

// 1 way
type TupleToUnion<T> = T extends unknown[] ? T[number] : T
type Without<T, U, K = TupleToUnion<U>> = T extends [infer P, ...infer R]
  ? P extends K
    ? Without<R, U>
    : [P, ...Without<R, U>]
  : []

// 2 way
type IndexOf<T, U, Res extends unknown[] = []> = T extends [infer P, ...infer R]
  ? Equal<U, P> extends true
    ? Res['length']
    : IndexOf<R, U, [...Res, P]>
  : -1
type Exist<T, U> = T extends unknown[] ? (IndexOf<T, U> extends -1 ? false : true) : Equal<T, U>
type Without<T, U> = T extends [infer P, ...infer R]
  ? Exist<U, P> extends false
    ? [P, ...Without<R, U>]
    : Without<R, U>
  : []

Zip

type Zip<T, U> = T extends [infer P, ...infer R]
  ? U extends [infer K, ...infer KR]
    ? [[P, K], ...Zip<R, KR>]
    : []
  : []

Fibonacci

type Fibonacci<
  T extends number,
  U extends unknown[] = [0],
  U1 extends unknown[] = [0],
  U2 extends unknown[] = [0],
> = U['length'] extends T ? U1['length'] : Fibonacci<T, [...U, 0], U2, [...U1, ...U2]>

Chunk

type Chunk<T, U, K extends unknown[] = []> = K['length'] extends U
  ? [K, ...Chunk<T, U, []>]
  : T extends [infer P, ...infer R]
  ? Chunk<R, U, [...K, P]>
  : K['length'] extends 0
  ? []
  : [K]

Split

type Split<S extends string, SEP extends string, Res extends string[] = []> = Equal<string, S> extends true
  ? string[]
  : S extends `${infer P}${SEP}${infer R}`
  ? Split<R, SEP, [...Res, P]>
  : SEP extends ''
  ? [...Res]
  : [...Res, S]

LengthOfString

type LengthOfString<S extends string, U extends string[] = []> = S extends `${infer P}${infer R}`
  ? LengthOfString<R, [...U, P]>
  : U['length']

RequiredKeys

type RequiredKeys<T> = keyof { [R in keyof T as T[R] extends Required<T>[R] ? R : never]: never }

Assign

type Assign<T extends Record<string, unknown>, U extends unknown[]> = U extends [infer P, ...infer R]
  ? Assign<Merge<T, P>, R>
  : T

TypedGet

type GetKey<T extends unknown[] | Record<string, any>, K extends string> = T extends unknown[]
  ? T[0] extends Record<string, unknown>
    ? T[0][K]
    : never
  : T extends Record<string, any>
  ? T[K]
  : never

type Get<O extends Record<string, any>, T extends string> = unknown extends O[T]
  ? T extends `${infer K}.${infer R}`
    ? R extends string
      ? O[R] extends unknown
        ? Get<GetKey<O, K>, R>
        : O[R]
      : GetKey<O, K>
    : T extends string
    ? GetKey<O, T>
    : never
  : O[T]

概念 ​

优势 ​

基础类型 ​

函数类型 ​

interface ​

可选属性 ​

readonly 只读属性 ​

自定义属性(可索引的类型) ​

类 ​

枚举 ​

高级类型 ​

联合类型 ​

交叉类型 ​

类型别名 ​

与 interface 对比 ​

索引类型 ​

泛型约束 ​

映射类型 ​

in ​

​

泛型 ​

体操 ​

Await ​

Pick ​

Exclude ​

First ​

Readonly ​

IF ​

Concat ​

Push ​

Includes ​

Equal ​

Unshift ​

Parameters ​

Readonly2 ​

Chainable ​

DeepReadonly ​

TupleToUnion ​

Last ​

PromiseAll ​

Lookup ​

Capitalize ​

​

AnyOf ​

IsNever ​

Replace ​

ReplaceAll ​

Parameters ​

Flatten ​

Absolute ​

IsUnion ​

ReplaceKeys ​

PickByType ​

OmitByType ​

StartsWith ​

EndsWith ​

PartialByKeys ​

RequiredByKeys ​

IndexOf ​

LastIndexOf ​

Unique ​

MapTypes ​

Shift ​

Reverse ​

TupleToNestedObject ​

FlipArguments ​

Flip ​

Subsequence ​

Without ​

Zip ​

Fibonacci ​

Chunk ​

Split ​

LengthOfString ​

RequiredKeys ​

Assign ​

TypedGet ​

概念

优势

基础类型

函数类型

interface

可选属性

readonly 只读属性

自定义属性(可索引的类型)

类

枚举

高级类型

联合类型

交叉类型

类型别名

与 interface 对比

索引类型

泛型约束

映射类型

in

泛型

体操

Await

Pick

Exclude

First

Readonly

IF

Concat

Push

Includes

Equal

Unshift

Parameters

Readonly2

Chainable

DeepReadonly

TupleToUnion

Last

PromiseAll

Lookup

Capitalize

AnyOf

IsNever

Replace

ReplaceAll

Parameters

Flatten

Absolute

IsUnion

ReplaceKeys

PickByType

OmitByType

StartsWith

EndsWith

PartialByKeys

RequiredByKeys

IndexOf

LastIndexOf

Unique

MapTypes

Shift

Reverse

TupleToNestedObject

FlipArguments

Flip

Subsequence

Without

Zip

Fibonacci

Chunk

Split

LengthOfString

RequiredKeys

Assign

TypedGet