Typescript

Question

好的，这是一篇很长而且非常具体的文章。非常感谢任何输入。

我写了一个递归 Omit 类型，它接受一个类型 T 和一个字符串元组（一个 'path'），并索引到 T，删除路径上的最后一项并返回该类型。

我已经看过 - 但它涉及递归地省略相同的键而不是沿着路径遍历。

我也看过，但它涉及运行时间并且是关于一级省略。

我的实现：

// for going along the tuple that is the path
type Tail<T extends any[]> = ((...args: T) => void) extends ((head: unknown, ...rest: infer U) => void) ? U : never;

type DeepOmit<T, Path extends string[]> = T extends object ? {
    0: Omit<T, Path[0]>;
    1: { [K in keyof T]: K extends Path[0] ? DeepOmit<T[K], Tail<Path>> : T[K] }
}[Path['length'] extends 1 ? 0 : 1] : T;

我想把 Path 限制为对 T 的有效遍历，例如：

Path = [K1, K2, K3, ..., K_n] such that:
K1 extends keyof T, K2 extends keyof T[K1], ... Kn extends keyof[T][K1]...[K_(n-1)]

第一次尝试

我写了一个类型，它采用类型 T 和路径 P 和 returns P 如果有效，否则 never :

type ExistingPathInObject<T, P extends any[]> = P extends [] ? P : {
    0: ExistingPathInObject<T[P[0]], Tail<P>> extends never ? never : P;
    1: never;
}[P[0] extends keyof T ? 0 : 1]

但是，在 DeepOmit 的签名中我不能强制执行 Path extends ExistingPathInObject<T,Path>，因为这是循环依赖。我提到这个尝试是因为可能有一种方法可以绕过循环并使用这种类型来验证 Path 作为对 T.

的有效遍历

第二次尝试

因为我似乎无法使用 Path 来约束自己，所以我尝试生成一个类型中所有现有路径的并集，然后要求 Path 对其进行扩展。我能想到的最好的是：

type Paths<T> = {
    0: { [K in keyof T]: T[K] extends object ? [K, Paths<T[K]>[keyof Paths<T[K]>]] : [K] }
    1: []
}[T extends object ? 0 : 1];

// an example type to test on
type HasNested = { a: string; b: { c: number; d: string } };

type pathTest = Paths<HasNested>;
//{
//  a: ["a"];
//  b: ["b", ["d"] | ["c"]];
//}

type pathTestUnion = Paths<HasNested>[keyof Paths<HasNested>]
// ["a"] | ["b", ["d"] | ["c"]]

这让我可以匹配写成树的路径：['a'] extends pathTestUnion 和 ['b', ['d']] extends pathTestUnion 都为真。我必须添加一个 [keyof T] 才能获得联合，但我不能将其放入类型 Paths 本身，因为它未被识别为有效。

完成所有这些后，我现在很难重写 DeepOmit 以使用此约束。这是我尝试过的：

type Types<T> = T[keyof T];

type TypeSafeDeepOmit<T, Path extends Types<Paths<T>>, K extends keyof T> =
    Path extends any[] ?
    T extends object ?
    { // T is object and Path is any[]
        0: Omit<T, K>;
        1: { [P in keyof T]: P extends Path[0] ? TypeSafeDeepOmit<T[P], Path[1], Path[1][0]> : T[P] }
    }[Path['length'] extends 1 ? 0 : 1] :
    T : // if T is not object
    never; // if Path is not any[]

type TSDO_Helper<T, P extends Types<Paths<T>>> = P extends any[] ? P[0] extends keyof T ? TypeSafeDeepOmit<T, P, P[0]> : never : never;

这很丑陋并且使用辅助类型来实际工作。我还必须告诉编译器 P extends any[] 和 P[0] extends keyof T，即使这正是 Paths 的目的。我在使用 Path[1] -

的 TypeSafeDeepOmit 递归调用中也遇到了错误

Type 'any[] & Path' is not assignable to type '[]'.
        Types of property 'length' are incompatible.
          Type 'number' is not assignable to type '0'

我已经通过设置 Path extends Types<Paths<T>> | [] 解决了这个问题，但我不确定这是正确的方法。

总结

那么，有没有更好的方法来强制执行有效路径？是否也可以支持路径联合，以便省略所有路径？现在我得到的结果是不同省略结果的联合。

Answer 1

评论太长了，不知道算不算回复

这是一个从 union-of-omits 到 multi-omit 的非常令人讨厌的转换（有许多可能的边缘情况）：

type NestedId<T, Z extends keyof any = keyof T> = (
  [T] extends [object] ? { [K in Z]: K extends keyof T ? NestedId<T[K]> : never } : T
) extends infer P ? { [K in keyof P]: P[K] } : never;

type MultiDeepOmit<T, P extends string[]> = NestedId<P extends any ? DeepOmit<T, P> : never>

它的工作方式（如果它确实有效）是采用像 {a: string, b: number} | {b: number, c: boolean} 这样的并集，并且只使用存在于该并集的所有成分中的键：{b: number}。很难做到这一点，并且会破坏可选属性，谁知道还有什么。

祝你好运，很抱歉还没有很好的答案。

Typescript - type safe deep omit，或者：如何列出合法的对象路径

Typescript - type safe deep omit, or: how to list legal object paths

recursion

recursive-datastructures

typescript-generics