TypeChallenges记录

July 7, 2023

12 Chainable Options

type Chainable<T = {}> = {
    // 此处用泛型 T 保存欲输出的类型
    option: <K extends keyof any, V>( // 获取参数 key value 的类型
        key: Exclude<K, keyof T>, // key 不能为 T 中已存在的键（注意必须在形参key上限制类型，而不能在泛型参数上限制）
        value: V, // 首先移除已存在的键名 K，再将键 K 设置为类型 V
    ) => Chainable<Omit<T, K> & { [P in K]: V }>;
    get: () => T;
};

20 Promise.all

//prettier-ignore
type Recursive<T extends readonly any[]> =
          // 处理空数组情况
        T["length"] extends 0 ? []
        : // 处理元组情况
        T extends [infer A, ...infer B] ? [Awaited<A>, ...Recursive<B>]
        : // 处理数组情况
        T extends Array<infer U> ? Array<Awaited<U>>
        : // never
          never;

//prettier-ignore
declare function PromiseAll<T extends any[]>(values: readonly [...T]): Promise<
  Recursive<T>
>;

// 把数组当作对象处理，将每个下标的值进行映射
//prettier-ignore
declare function PromiseAll<T extends any[]>(values: readonly [...T]): Promise<{
  [K in keyof T]: Awaited<T[K]>
}>

296 Permutation

https://github.com/type-challenges/type-challenges/issues/614

//prettier-ignore
type Permutation<T, U = T> = [T] extends [never]
  ? []
  : (T extends U
    ? [T, ...Permutation<Exclude<U, T>>]
    : never)

459 Flatten

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

type Flatten<S extends any[], T extends any[] = []> = S extends [infer X, ...infer Y]
    ? X extends any[]
        ? Flatten<[...X, ...Y], T>
        : Flatten<[...Y], [...T, X]>
    : T;

1042 IsNever

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

Distributive Conditional Types

// 根据*联合类型*(unions)在条件(extends)中*分发*(distribute)，以下代码
type IsNever<T> = T extends never ? true : false;
// 将导致结果为 never
type WillBeNever = IsNever<never>;
// 这是因为输入泛型 never 是空集，空集(在extends中)不会发生任何分配，所以只能得到返回类型 never

引申：any 为全集，将直接分配为条件分支的两个结果的并集

用方括号包裹 extends 两边的类型可防止类型分发

Typically, distributivity is the desired behavior. To avoid that behavior, you can surround each side of the extends keyword with square brackets.

type P<T> = T extends never ? true : false;
type A1 = P<never>; // never
type A2 = P<any>; // boolean

type Q<T> = [T] extends [never] ? true : false;
type B1 = Q<never>; // true
type B2 = Q<any>; // false

实际上，内置类型就是依据此原理

/**
 * 排除 T 中能分配(assign)给 U 的类型
 */
type Exclude<T, U> = T extends U ? never : T;

/**
 * 提取 T 中能分配(assign)给 U 的类型
 */
type Extract<T, U> = T extends U ? T : never;

1097 IsUnion

https://github.com/type-challenges/type-challenges/issues/1140

// 根据：联合类型中的其中一个类型，不能分配给联合类型中的其它类型（因为能分配的类型会收束）
// 通过两次使用*分发条件类型*，判断是否*不是*联合类型（而是单类型）
type DoubleDistribute<T, TRUE, FALSE, C = T> = T extends T ? (C extends T ? TRUE : FALSE) : never;
type IsUnion<T> = DoubleDistribute<T, "SingleType", "UnionType"> extends "SingleType" ? false : true;
// 注：此处写法只是为了便于理解

1367 Remove Index Signature

//prettier-ignore
type RemoveIndexSignature<T extends object> = {
  // Index Signature 指的就是 keyof any，但*不能是*一个 extends keyof any 的具体值
  // 因此只需要排除 keyof T 中是 keyof any 的键即可
    [K in keyof T as 
        string extends K ? never : 
        number extends K ? never : 
        symbol extends K ? never : 
    K]: T[K];
};

2257 MinusOne

递归法：https://github.com/type-challenges/type-challenges/issues/4377
由于 ts 编译器限制递归层数只适用于较小的数

type Pop<T extends any[]> = T extends [...infer U, any] ? U : never;
//prettier-ignore
type MinusOne<T extends number, A extends any[] = []> = 
    // 这里使用一个额外的泛型参数 A，用于将 T 转换为 length 为 T 的数组
    A['length'] extends T ? Pop<A>['length'] // 已经转换为 length 为 T 的数组，返回 length - 1
  : MinusOne<T, [...A, symbol]> // 递归地将 A 的 length 加 1

// 同理，只是用 spread 运算符替代了 Pop<T>
type MinusOne<T extends number, A extends symbol[] = []> = [...A, symbol]["length"] extends T
    ? A["length"]
    : MinusOne<T, [...A, symbol]>;

另：PlusOne

type PlusOne<T extends number, Len extends number = 0, Acc extends symbol[] = []> = T extends Len
    ? [...Acc, symbol]["length"]
    : PlusOne<T, [...Acc, T]["length"], [...Acc, symbol]>;

2757 PartialByKeys

本题不难，重点在于需要将交叉(Intersection)类型合并

type IntersectionToObj<T> = { [K in keyof T]: T[K] };

type PartialByKeys<T, K = any> = IntersectionToObj<
    {
        [P in keyof T as P extends K ? P : never]?: T[P];
    } & {
        [P in keyof T as P extends K ? never : P]: T[P];
    }
>;

也可以花哨一点，写成这样。这里 Omit<Intersection, never> 起到了合并作用

//prettier-ignore
type PartialByKeys<T, U = keyof T> = Omit<
    Partial<Pick<T, U & keyof T>> 
    &
    Omit<T, U & keyof T>
, never>;

2946 ObjectEntries

type ArrayValues<T extends any[]> = T[number];
type ObjectValues<T extends object> = T[keyof T];

type a = ArrayValues<[1, 2, 3]>; // 2 | 1 | 3
type b = ObjectValues<{ 0: 1; 1: 2; 2: 3 }>; // 2 | 1 | 3

type c = undefined extends never ? true : false; // false
type d = { key?: undefined } extends { key?: never } ? true : false; // true
// { key?: never }
//      |
//    这个问号表示键不存在，或值为 undefined 与指定值的类型的联合类型
//    注意：虽然键可能不存在，但 keyof 运算符还是可以得到键
//    因此：d 实际相当于 e，而不是 c
type e = undefined extends never | undefined ? true : false; // true

type f = Required<{ key?: undefined }>; // { key: never }
// type Required<T> = { [P in keyof T]-?: T[P]; }
//                                     |
//                                   这个减号把 undefined 类型排除了

type ObjectEntries<T extends object, U = Required<T>> = ObjectValues<{
    [K in keyof U]: [K, U[K] extends never ? undefined : U[K]];
}>;

3376 InorderTraversal

本题不难，问题依旧出在 Distributive Conditional Types

再次强调：联合类型(unions)在条件(extends)中分发(distribute)

type InorderTraversal<T extends TreeNode | null> = [T] extends [TreeNode]
    ? [...InorderTraversal<T["left"]>, T["val"], ...InorderTraversal<T["right"]>]
    : [];

为了将一个联合类型收束到指定类型，须用方括号括起来。
还要注意，在本题中不能 [T] extends [null] ? [] : /* 此处 T 还是 TreeNode | null */

// type NonNullable<T> = T & {}
// 也可以用 NonNullable 规避 extends 中 null 的分发
type InorderTraversal<T extends TreeNode | null, Node extends TreeNode = NonNullable<T>> = T extends null
    ? []
    : [...InorderTraversal<Node["left"]>, Node["val"], ...InorderTraversal<Node["right"]>];

8767 Combination

联合类型在条件中分发，相当于 map 后再联合

// Aux 用于递归 union 类型
type Aux<U, A = U> = U extends string ? U | `${U} ${Aux<Exclude<A, U>>}` : never;

// 数组转换为 union
type Combination<T extends string[]> = Aux<T[number]>;

8987 Subsequence

type Subsequence<T extends any[]> = T extends [infer U, ...infer Rest]
    ? Subsequence<Rest> | [U, ...Subsequence<Rest>]
    : [];

注意到 typescript 支持如下语法

type ts = [1, ...([2] | [3])]; // [1, 2] | [1, 3]

←Back to home