模式匹配做提取

数组类型

提取数组第一个元素的类型

1
2
3
type GetFirst<Arr extends unknown[]> = Arr extends [infer First, ...unknown[]]
  ? First
  : never;

提取数组最后一个元素的类型

1
2
3
type GetLast<Arr extends unknown[]> = Arr extends [...unknown[], infer Last]
  ? Last
  : never;

取去掉最后一个元素的数组

1
2
3
4
5
type PopArr<Arr extends unknown[]> = Arr extends []
  ? []
  : Arr extends [...infer Rest, unknown]
  ? Rest
  : never;

字符串类型

字符串是否以某个特定字符开头

1
2
3
4
type StartWidth<
  Str extends string,
  Prefix extends String
> = Str extends `${Prefix}${string}` ? true : false;

将字符串中某个特定的部分替换成别的字符串

1
2
3
4
5
6
7
type ReplaceStr<
  Str extends string,
  From extends string,
  To extends string
> = Str extends `${infer Prefix}${From}${infer Suffix}`
  ? `${Prefix}${To}${Suffix}`
  : Str;

字符串去除右空格

1
2
3
4
5
6
type TrimStrRight<Str extends string> = Str extends `${infer Rest}${
  | " "
  | "\n"
  | "\t"}`
  ? TrimStrRight<Rest>
  : Str;

函数类型

提取函数参数的类型

1
2
3
4
5
type GetParameters<Func extends Function> = Func extends (
  ...args: infer Args
) => unknown
  ? Args
  : never;

提取函数返回值的类型

1
2
3
4
5
type GetReturnType<Func extends Function> = Func extends (
  ...args: any[]
) => infer ReturnType
  ? ReturnType
  : never;

构造器

提取构造器参数的类型

1
2
3
4
type GetInstanceParameters<ConstructorType extends new (...args: any) => any> =
  ConstructorType extends new (...args: infer ParametersType) => any
    ? ParametersType
    : never;

提取构造器返回值类型

1
2
3
4
type GetInstanceReturnType<ConstructorType extends new (...args: any) => any> =
  ConstructorType extends new (...args: any) => infer InstanceType
    ? InstanceType
    : never;

索引类型

提取 props 中 ref 值的类型

1
2
3
4
5
type GetRefProps<Props> = "ref" extends keyof Props
  ? Props extends { ref?: infer Value | undefined }
    ? Value
    : never
  : never;

重新构造做变换

TypeScript 的 type、infer、类型参数声明的变量都不能修改，想对类型做各种变换产生新的类型就需要重新构造。

数组类型的构造

给数组/元组添加新类型

1
type Push<Arr extends unknown[], Ele> = [...Arr, Ele];

元组重组

1
2
3
4
5
6
7
8
9
10
11
12
13
14
type tuple1 = [1, 2];
type tuple2 = ["guang", "dong"];
// 重组成如下的元组
type tuple = [[1, "guang"], [2, "dong"]];

// 代码实现
type Zip<One extends unknown[], Other extends unknown[]> = One extends [
  infer OneFirst,
  ...infer OneRest
]
  ? Other extends [infer OtherFirst, ...infer OtherRest]
    ? [[OneFirst, OtherFirst], ...Zip<OneRest, OtherRest>]
    : []
  : [];

字符串类型的构造

将字符串首字母大写

1
2
3
4
type CapitalizeStr<Str extends string> =
  Str extends `${infer First}${infer Rest}`
    ? `${Uppercase<First>}${Rest}`
    : Str;

将字符串下划线转驼峰

```tstype CamelCase<Str extends string> = Str extends${infer Left}_${infer Right}${infer Rest}?${Left}${Uppercase}${CamelCase}`
Str;
1
2
3
4
5
6
7
8

**删除字符串子串**

```ts
type DropSubStr<Str extends string, SubStr extends string> =
    Str extends `${infer Prefix}${SubStr}${infer Suffix}`
        ? DropSubStr<`${Prefix}${Suffix}`, SubStr>
        : Str;

函数类型的构造

给函数添加一个参数

1
2
3
4
5
type AppendArgument<Func extends Function, Arg> = Func extends (
  ...args: infer Args
) => infer ReturnType
  ? (...args: [...Args, Arg]) => ReturnType
  : never;

索引类型的构造

索引类型是聚合多个元素的类型。比如 class 和对象都是索引类型。索引类型的元素的类型只能是 string、number 或者 Symbol 等类型。

索引类型的每个元素的类型可以添加修饰符：readonly（只读）、?（可选）。

映射类型语法

1
2
3
type Mapping<Obj extends object> = {
  [Key in keyof Obj]: Obj[Key];
};

用 as 做重映射改变索引类型的 Key 转成大写

1
2
3
type UppercaseKey<Obj extends object> = {
  [Key in keyof Obj as Uppercase<Key & string>]: Obj[Key];
};

因为这里索引的类型可能是 string、number 或 symbol 类型，但是这里转成大写只能是限定为 string。

TS 内置高级类型 Record

1
type Record<K extends string | number | symbol, T> = { [P in K]: T };

UppercaseKey 重写版：用 Record 来约束索引类型而不是 object

1
2
3
type UppercaseKey<Obj extends Record<string, any>> = {
  [Key in keyof Obj as Uppercase<Key & string>]: Obj[Key];
};

给索引类型添加只读的高级类型

1
2
3
type ToReadonly<T> = {
  readonly [Key in keyof T]: T[Key];
};

给索引类型添加可选的高级类型

1
2
3
type ToPartial<T> = {
  [Key in keyof T]?: T[Key];
};

给索引类型去掉只读修饰符

1
2
3
type ToMutable<T> = {
  -readonly [Key in keyof T]: T[Key];
};

给索引类型去掉可选修饰符

1
2
3
type ToRequired<T> = {
  [Key in keyof T]-?: T[Key];
};

返回特定值的类型的索引类型

1
2
3
type FilterByValueType<Obj extends Record<string, any>, ValueType> = {
  [Key in keyof Obj as Obj[Key] extends ValueType ? Key : never]: Obj[Key];
};

递归复用做循环

Promise 的递归复用

提取 Promise 值的类型

1
2
3
4
5
6
7
type DeepPromiseValueType<P extends Promise<unknown>> = P extends Promise<
  infer ValueType
>
  ? ValueType extends Promise<unknown>
    ? DeepPromiseValueType<ValueType>
    : ValueType
  : never;

提取 Promise 值的类型简化版

1
2
3
type DeepPromiseValueType<T> = T extends Promise<infer ValueType>
  ? DeepPromiseValueType<ValueType>
  : never;

数组类型的递归

反转元组

1
2
3
4
5
6
type ReversrArr<Arr extends unknown[]> = Arr extends [
  infer First,
  ...infer Rest
]
  ? [...ReversrArr<Rest>, First]
  : Arr;

查找元素

1
2
3
4
5
6
7
8
9
10
type Includes<Arr extends unknown[], FindItem> = Arr extends [
  infer First,
  ...infer Rest
]
  ? IsEqual<First, FindItem> extends true
    ? true
    : Includes<Rest, FindItem>
  : false;
type IsEqual<A, B> = (A extends B ? true : false) &
  (B extends A ? true : false);

删除元素

1
2
3
4
5
6
7
8
9
10
11
type RemoveItem<
  Arr extends unknown[],
  Item,
  Result extends unknown[] = []
> = Arr extends [infer First, ...infer Rest]
  ? IsEqual<First, Item> extends true
    ? RemoveItem<Rest, Item, Result>
    : RemoveItem<Rest, Item, [...Result, First]>
  : Result;
type IsEqual<A, B> = (A extends B ? true : false) &
  (B extends A ? true : false);

构造指定类型的数组

1
2
3
4
5
type BuildArray<
  Length extends number,
  Ele = unknown,
  Arr extends unknown[] = []
> = Arr["length"] extends Length ? Arr : BuildArray<Length, Ele, [...Arr, Ele]>;

字符串类型的递归

替换子串

1
2
3
4
5
6
7
type ReplaceAll<
  Str extends string,
  From extends string,
  To extends string
> = Str extends `${infer Left}${From}${infer Right}`
  ? `${Left}${To}${ReplaceAll<Right, From, To>}`
  : Str;

提取字符做联合类型

1
2
3
4
type StringToUnion<Str extends string> =
  Str extends `{infer First}${infer Rest}`
    ? First | StringToUnion<Rest>
    : never;

反转字符串

1
2
3
type ReverseStr<Str extends string> = Str extends `${infer First}${infer Rest}`
  ? `${ReverseStr<Rest>}${First}`
  : Str;

对象类型的递归

深度递归

1
2
3
4
5
6
7
8
9
type DeepToReadonly<T extends Record<string, any>> = T extends any
  ? {
      readonly [Key in keyof T]: T[Key] extends Object
        ? T[Key] extends Function
          ? T[Key]
          : DeepToReadonly<T[Key]>
        : T[Key];
    }
  : never;

数组长度做计算

数组长度实现加减乘除

加法

1
2
3
4
5
6
7
8
9
10
type BuildArray<
  Length extends number,
  Ele = unknown,
  Arr extends unknown[] = []
> = Arr["length"] extends Length ? Arr : BuildArray<Length, Ele, [...Arr, Ele]>;

type Add<Num1 extends number, Num2 extends number> = [
  ...BuildArray<Num1>,
  ...BuildArray<Num2>
]["length"];

减法

1
2
3
4
5
6
type Subtract<
  Num1 extends number,
  Num2 extends number
> = BuildArray<Num1> extends [...BuildArray<Num2>, ...infer Rest]
  ? Rest["length"]
  : never;

乘法

1
2
3
4
5
6
7
type Multiple<
  Num1 extends number,
  Num2 extends number,
  ResultArr extends unknown[] = []
> = Num2 extends 0
  ? ResultArr["length"]
  : Multiple<Num1, Subtract<Num2, 1>, [...ResultArr, ...BuildArray<Num1>]>;

除法

1
2
3
4
5
6
7
type Divide<
  Num1 extends number,
  Num2 extends number,
  ResultArr extends unknown[] = []
> = Num1 extends 0
  ? ResultArr["length"]
  : Divide<Subtract<Num1, Num2>, Num2, [...ResultArr, unknown]>;

数组长度实现计数

计算字符串长度

1
2
3
4
5
6
type StrLen<
  Str extends string,
  CountArr extends unknown[] = []
> = Str extends `${string}${infer Rest}`
  ? StrLen<Rest, [...CountArr, unknown]>
  : CountArr["length"];

比较 2 个数值谁更大

1
2
3
4
5
6
7
8
9
10
11
type GreaterThan<
  Num1 extends number,
  Num2 extends number,
  CountArr extends unknown[] = []
> = Num1 extends Num2
  ? false
  : CountArr["length"] extends Num2
  ? true
  : CountArr["length"] extends Num1
  ? false
  : GreaterThan<Num1, Num2, [...CountArr, unknown]>;

实现斐波那契数列

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
type FibonacciLoop<
  PrevArr extends unknown[],
  CurrentArr extends unknown[],
  IndexArr extends unknown[] = [],
  Num extends number = 1
> = IndexArr["length"] extends Num
  ? CurrentArr["length"]
  : FibonacciLoop<
      CurrentArr,
      [...PrevArr, ...CurrentArr],
      [...IndexArr, unknown],
      Num
    >;

type Fibonacci<Num extends number> = FibonacciLoop<[1], [], [], Num>;

聚合分散可简化

分布式条件类型

当类型参数为联合类型，并且在条件类型左边直接引用该类型参数的时候，TypeScript 会把每一个元素单独传入来做类型运算，最后再合并成联合类型，这种语法叫做分布式条件类型。

1
2
3
4
type Union = "a" | "b" | "c";
type UppercaseA<Item extends string> = Item extends "a"
  ? Uppercase<Item>
  : Item;

这和联合类型遇到字符串时的处理一样：

1
2
3
type Union = "a" | "b";
type str = `${Union}~`;
// type str = 'a~' | 'b~';

数组转联合类型

1
2
3
type Arr = ["a", "b", "c"];
type UnionArr = Arr[number];
// type UnionArr = 'a' | 'b' | 'c';

判断是否是联合类型

1
type isUnion<A, B = A> = A extends A ? ([B] extends [A] ? false : true) : never;

当 A 是联合类型时：

  • A extends A 这种写法是为了触发分布式条件类型，让每个类型单独传入处理的，没别的意义。
  • A extends A 和 [A] extends [A] 是不同的处理，前者是单个类型和整个类型做判断，后者两边都是整个联合类型，因为只有 extends 左边直接是类型参数才会触发分布式条件类型。

BEM

1
2
3
4
5
type BEM<
  Block extends string,
  Element extends string[],
  Modifiers extends string[]
> = `${Block}__${Element[number]}--${Modifiers[number]}`;

全组合

1
2
3
4
5
6
7
8
9
// A 和 B 的全组合
type Combination<A extends string, B extends string> =
    A | B | `${A}${B}` | `${B}${A}`

// 全组合
type AllCombinations<A extends string, B extends string = A> =
    A extens A
        ? Combination<A, AllCombinations<Exclude<B, A>>>
        : never;

特殊特性要记清

IsAny

any 类型与任何类型的交叉都是 any，也就是 1 & any 结果是 any。

1
type IsAny<T> = "a" extends 1 & T ? true : false;

IsEqual

1
2
3
4
5
6
7
8
9
10
// 以下这种写法不能判断 isAny，isEqual<'a', any> 会返回 true
type IsEqual<A, B> = (A extends B ? true : false) &
  (B extends A ? true : false);

// 以下这个可以判断 IsEqual2<'a', any> 会返回 false
type IsEqual2<A, B> = (<T>() => T extends A ? 1 : 2) extends <
  T
>() => T extends B ? 1 : 2
  ? true
  : false;

IsUnion

1
type IsUnion<A, B> = A extends A ? ([B] extends [A] ? false : true) : never;

IsNever

never 在条件类型中也比较特殊，如果条件类型左边是类型参数，并且传入的是 never，那么直接返回 never。

1
2
3
4
5
6
type TestNever<T> = T extends number ? 1 : 2;
// 如下会返回 never
type result = TestNever<never>;

// 正确的 IsNever
type IsNever<T> = [T] extends [never] ? true : false;

除此之外，any 在条件类型中也比较特殊，如果类型参数为 any，会直接返回 trueType 和 falseType 的合并。

1
2
3
type TestAny<T> = T extends number ? 1 : 2;
// 如下会返回 1 | 2
type result = TestAny<any>;

IsTuple

元组类型的 length 是数字字面量，而数组的 length 是 number。

1
2
3
4
5
6
7
8
9
type IsTuple<T> = T extends [...infer Eles]
  ? NotEqual<Ele["length"], number>
  : false;

type NotEqual<A, B> = (<T>() => T extends A ? 1 : 2) extends <
  T
>() => T extends B ? 1 : 2
  ? false
  : true;

UnionToIntersection

联合类型转交叉类型。

1
2
3
4
5
type UnionToIntersecion<U> = (U extends U ? (x: U) => unknown : never) extends (
  x: infer R
) => unknown
  ? R
  : never;

GetOptional

提取索引类型中的可选索引。

1
2
3
4
5
6
type GetOptional<Obj extends Record<string, any>> = {
  [Key in keyof Obj as {} extends Pick<Obj, Key> ? Key : never]: Obj[Key];
};

// Pick 是 TS 内置高级类型
type Pick<T, K extends keyof T> = { [P in K]: T[P] };

GetRequired

提取索引类型中的非可选索引构造成新的索引类型。

1
2
3
type GetRequired<Obj extends Record<string, any>> = {
  [Key in keyof Obj as {} extends Pick<Obj, Key> ? never : Key]: Obj[Key];
};

RemoveIndexSignature

过滤掉索引类型中的可索引签名，构造成一个新的索引类型。
索引签名的特性：索引签名不能构造成字符串字面量类型，因为它没有名字，而其他索引可以

1
2
3
type RemoveIndexSignature<Obj extends Record<string, any>> = {
  [Key in keyof Obj as Key extends `${infer Str}` ? Str : never]: Obj[Key];
};

ClassPublicProps

过滤 class 的 public 属性。
根据特性：keyof 只能拿到 class 的 public 索引，private 和 protected 的索引会被忽略。

1
2
3
type ClassPublicProps<Obj extends Record<string, any>> = {
  [Key in keyof Obj]: Obj[Key];
};

as const

TypeScript 默认推导出来的类型并不是字面量类型。

1
2
3
4
5
6
7
8
9
const obj = {
  a: 1,
  b: 2,
};
type objType = typeof obj;
// type objType = {
//     a: number;
//     b: number
// }

如果想要推到出字面量，就需要用 as const：

1
2
3
4
5
6
7
const arr = [1, 2, 3];
type arrType = typeof arr;
// type arrType = number[];

const arr2 = [1, 2, 3] as const;
type arrType2 = typeof arr2;
// type arrType2 = readonly [1, 2, 3];

反转 3 个元素的元组类型，需要加上 readonly 才能匹配成功。

1
2
3
type ReverseArr<Arr> = Arr extends readonly [infer A, infer B, infer C]
  ? [C, B, A]
  : never;

练一练

实现 ParseQueryString

将 ‘a=1&b=2&c=3’ 转成 {a: 1, b: 2, c: 3}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
type ParseQueryString<Str extends string> =
  Str extends `${infer Param}&${infer Rest}`
    ? MergeParams<ParseParams<Param>, ParseQueryString<Rest>>
    : ParseParam<Str>;

type ParseParams<Param extends string> =
  Param extends `${infer Key}=${infer Value}`
    ? {
        [K in Key]: Value;
      }
    : Record<string, any>;

type MergeParams<
  OneParam extends Record<string, any>,
  OtherParam extends Record<string, any>
> = {
  [Key in keyof OneParam | keyof OtherParam]: Key extends keyof OneParam
    ? Key extends keyof OtherParam
      ? MergeValue<OneParam[Key], OtherParam[Key]>
      : OneParam[Key]
    : Key extends keyof OtherParam
    ? OtherParam[Key]
    : never;
};

type MergeValue<One, Other> = One extends Other
  ? One
  : Other extends unknown[]
  ? [One, ...Other]
  : [One, Other];

TS 内置的高级类型

Parameters

提取函数类型的参数类型

1
2
3
4
5
type Parameters<T extends (...args: any) => any> = T extends (
  ...args: infer P
) => any
  ? P
  : never;

ReturnType

提取函数类型的返回值类型

1
2
3
4
5
type ReturnType<T extends (...args: any) => any> = T extends (
  ...args: any
) => infer R
  ? R
  : never;

ConstructorParameters

提取构造函数的参数类型

1
2
3
4
5
type ConstructorParameters<T extends new (...ars: any) => any> = T extends new (
  ...args: infer P
) => any
  ? P
  : never;

InstanceType

提取构造器返回值类型

1
2
3
4
5
type InstanceType<T extends new (...ars: any) => any> = T extends new (
  ...ars: any
) => infer R
  ? R
  : any;

ThisParameterType

提取函数参数中 this 的类型

1
2
3
type ThisParameterType<T> = T extends (this: infer U, ...args: any[]) => any
  ? U
  : unknown;

OmitThisParameter

去除函数参数中的 this 类型，并且返回一个新的类型

1
2
3
4
5
6
type OmitThisParameter<T> =
    unknown extends ThisParameterType<T>
        ? T
        : T extends (...args: infer A) => infer R
            ? （...args: A） => infer R
            : T;

Partial

把索引类型的所有索引变成可选类型

1
2
3
type Partial<T> = {
  [P in keyof T]?: T[P];
};

Required

把索引类型里可选索引改成必选索引

1
2
3
type Required<T> = {
  [P in keyof T]-?: T[P];
};

Readonly

索引类型的索引添加只读

1
2
3
type Readonly<T> = {
  readonly [P in keyof T]: T[P];
};

Pick

过滤出指定的索引类型

1
2
3
type Pick<T, K extends keyof T> = {
  [P in K]: T[P];
};

Record

创建索引类型

keyof any 会返回 string | number | symbol

1
2
3
type Record<K extends keyof any, T> = {
  [P in K]: T;
};

如果 Record 里的第一个参数是 string | number | symbol，那么创建的就是索引签名索引类型：

1
2
3
4
type RecordRes = Record<string, number>;
// RecordRes = {
//     [x: string]: number;
// }

Exclude

去掉联合类型中的某些类型，即取差集

联合类型当作为类型参数出现在条件类型左边时，会被分散成单个类型传入，这叫做分布式条件类型。

1
type Exclude<T, U> = T extends U ? never : T;

Extract

提取联合类型中的某些类型，即取交集

1
type Extract<T, U> = T extends U ? T : never;

Omit

去掉某部分索引类型的索引构成新索引类型

1
type Omit<T, K in keyof any> = Pick<T, EXclude<keyof T, K>>;

Awaited

提取 Promise 的返回值类型

1
2
3
4
5
6
7
8
type Awaited<T> =
    T extends null | undefined
        ? T
        : T extends object & { then(onfulfilled: infer F): any}
            ? F extends ((value, infer V, ...ars: any) => any)
                ? Awaited<V>
                : never
            : T;

NonNullable

判断是否是空类型，即不是 null 或 undefined

1
type NonNullable<T> = T extends null | unfefined ? never : T;

Uppercase、Lowercase、Capitalize、Uncapitalize

这几个类型分别是实现大写、小写、首字母大写、去掉首字母大写的。
他们的实现是直接用 js 实现的。

综合实战

KebabCaseToCamelCase

‘aa-bb-cc’ 这种是 KebabCase，而 ‘aaBbCc’ 这种是 CamelCase

1
2
3
4
type KebabCaseToCamelCase<Str extends string> =
  Str extends `${infer Item}-${infer Rest}`
    ? `${Item}${KebabCaseToCamelCase<Capitalize<Rest>>}`
    : Str;

CamelCaseToKebabCase

1
2
3
4
5
6
type CamelCaseToKebabCase<Str extends string> =
  Str extends `${infer First}${infer Rest}`
    ? First extends Lowercase<First>
      ? `${First}${CamelCaseToKebabCase<Rest>}`
      : `-${Lowercase<First>}${CamelCaseToKebabCase<Rest>}`
    : Str;

Chunk

对数组做分组，比如 1、2、3、4、5 的数组，每两个为 1 组，那就可以分为 1、2 和 3、4 以及 5 这三个 Chunk。

1
2
3
4
5
6
7
8
9
10
type Chunk<
  Arr extends unknown[],
  ItemLen extends number,
  CurItem extends unknown[] = [],
  Res extends unknown[] = []
> = Arr extends [infer First, ...infer Rest]
  ? CurItem["length"] extends ItemLen
    ? Chunk<Rest, ItemLen, [First], [...Res, CurItem]>
    : Chunk<Rest, ItemLen, [...CurItem, First], Res>
  : [...Res, CurItem];

TupleToNestedObject

根据数组类型，比如 [‘a’, ‘b’, ‘c’] 的元组类型，再加上值的类型 ‘xxx’，构造出这样的索引类型：

1
2
3
4
5
6
7
{
  a: {
    b: {
      c: "xxx";
    }
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
type TupleToNestedObject<Tuple extends unknown[], ValueType> = Tuple extends [
  infer First,
  ...infer Rest
]
  ? {
      [Key in First as Key extends keyof any
        ? Key
        : never]: Rest extends unknown[]
        ? TupleToNestedObject<Rest, ValueType>
        : ValueType;
    }
  : ValueType;

PartialObjectPropByKeys

把一个索引类型的某些 Key 转为 可选的，其余的 Key 不变。

1
2
3
4
5
6
7
8
9
10
11
type PartialObjectPropByKeys<
  Obj extends Record<string, any>,
  Key extends keyof any
> = Partial<Pick<Obj, Extract<keyof Obj, Key>>> & Omit<Obj, Key>;

type PartialObjectPropByKeys2<
  Obj extends Record<string, any>,
  KeyType extends keyof any
> = {
  [Key in keyof Obj as Key extends KeyType ? Key? : Key]: Obj[Key];
};

函数重载的三种写法

第一种

1
2
3
4
5
function add(a: number, b: number): number;
function add(a: string, b: string): string;
function add(a: any, b: any) {
  return a + b;
}

第二种

1
2
3
4
5
interface Func {
  (a: number, b: number): number;
  (a: string, b: string): string;
}
const add: Func = (a: any, b: any) => a + b;

第三种

1
2
type Func = ((a: number, b: number) => number) & ((a: string, b: string): string)
const add: Func = (a: any, b: any) => a + b;

UnionToTuple

将联合类型转成元组。

1
2
3
4
5
6
7
8
9
10
11
12
type UnionToTuple<T> = UnionToIntersection<
  T extends any ? () => T : never
> extends () => infer ReturnType
  ? [...UnionToTuple<Exclude<T, ReturnType>>, ReturnType]
  : [];

// 联合转交叉
type UnionToIntersection<U> = (
  U extends U ? (x: U) => unknown : never
) extends (x: infer R) => unknown
  ? R
  : never;

join

实现一个类似的效果，将：

1
2
const res = join("-")("guang", "and", "dong");
// 转成 res = 'guang-and-dong'

join 代码实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
declare function join<Delimiter extends string>(
  delimiter: Delimiter
): <Items extends string[]>(...parts: Items) => JoinType<Items, Delimiter>;

type JoinType<
  Items extends any[],
  Delimiter extends string,
  Result extends string = ""
> = Items extends [infer First, ...infer Rest]
  ? JoinType<Rest, Delimiter, `${Result}${First & string}-`>
  : RemoveLastDelimiter<Result>;

type RemoveLastDelimiter<Str extends string> = Str extends `${infer Rest}-`
  ? Rest
  : Str;

AllKeyPath

拿到一个索引类型的所有 key 的路径。

1
2
3
4
5
6
7
type AllKeyPath<Obj extends Record<string, any>> = {
  [Key in keyof Obj]: Key extends string
    ? Obj[Key] extends Record<string, any>
      ? Key | `${Key}.${AllKeyPath<Obj[Key]>}`
      : Key
    : never;
}[keyof Obj];

Defaultize

实现这样一个高级类型，对 A、B 两个索引类型做合并，如果是只有 A 中有的不变，如果是 A、B 都有的就变为可选，只有 B 中有的也变为可选。

1
2
3
type Defaultize<A, B> = Pick<A, Exclude<keyof A, keyof B>> &
  Partial<Pick<A, Extract<keyof A, keyof B>>> &
  Partial<Pick<B, Exclude<keyof B, keyof A>>>;

infer extends

枚举值转联合类型

以下会把枚举的数值类型转成字符串类型。

1
2
3
4
5
6
7
enum Code {
  a = 111,
  b = 222,
  c = "abc",
}
type res = `${Code}`;
// res = '111' | '222' | 'abc'

StrToNum

使用 infer extends 后就就可以正常使用了。

1
2
3
4
5
6
7
8
enum Code {
  a = 111,
  b = 222,
  c = "abc",
}
type StrToNum<Str> = Str extends `${infer Num extends number}` ? Num : Str;
type res = StrToNum<`${Code}`>;
// res = 'abc' | 111 | 222