在函数中使用递归类型时出错

Question

我有一个递归类型，它从嵌套对象中提取索引并将它们放入一个扁平的强类型元组中，如下所示：

type NestedRecord = Record<string, any>

type RecursiveGetIndex<
  TRecord extends NestedRecord,
  TPreviousIndices extends any[] = []
> = {
  [K in keyof TRecord]: TRecord[K] extends NestedRecord
    ? RecursiveGetIndex<
        TRecord[K],
        AppendToTuple<TPreviousIndices,K>
      >
    : AppendToTuple<TPreviousIndices, K>
}[keyof TRecord]

type AppendToTuple<T extends any[], U> = [...T, U] 

当使用嵌套对象类型的具体实例调用时，它可以正常工作，例如：

type AnIndex = RecursiveGetIndex<{ foo: { bar: { baz: number}}}> 

换句话说，正如预期的那样，AnIndex 被键入为["foo", "bar", "baz"]

但是，当我尝试在函数中使用 Recursive 类型时，出现递归错误：

function doSomething<T extends NestedRecord>(arg:T){
    type Nested = RecursiveGetIndex<T>
    const doMore = (n: Nested) => {
        console.log(n) //Type instantiation is excessively deep and possibly nested
    }
}

哪一种对我来说有意义，因为 TS 并不知道T 的递归深度可能有多大。

正确吗？为什么 TS 不等到它看到 doSomething 被实例化后才担心递归？

而且，如果我事先知道传递给函数的arg 永远不会超过 TS 递归限制（我相信是 50），是否有某种方法可以避免该错误。即，我可以以某种方式告诉 typescript 吗？

我已经看到了基本上通过使用递减数组类型来限制递归的解决方案，例如this SO answer。这是我能做到的最好的吗？

Playground with the code.

更新

根据船长-yossarian 的建议，以下工作：

type RecursiveGetIndex<
  TRecord extends NestedRecord,
  TPreviousIndices extends any[] = [],
  TDepth extends number = 5
> = 10 extends TPreviousIndices["length"] ? TPreviousIndices : {
  [K in keyof TRecord]: TRecord[K] extends NestedRecord
    ? RecursiveGetIndex<
        TRecord[K],
        AppendToTuple<TPreviousIndices,K>
      >
    : AppendToTuple<TPreviousIndices, K>
}[keyof TRecord]

但是，如果此数字大于 10，则会再次出现错误。我原以为应该是 50。我的类型是否比我想象的更递归？

Updated playground.

Answer 1

RecursiveGetIndex<NestedRecord> is the real problem here 这是因为any 是如何用于条件类型的。

由于您的泛型被限制为NestedRecord，因此打字稿必须尝试将RecursiveGetIndex 应用于函数内部的约束以进行类型检查，但这意味着TRecord[K] 是any，因此条件@ 987654329@ 最终会评估两个分支，因为一个分支最终会以同样的方式再次调用 RecursiveGetIndex。

一旦TRecord=any 使用您的原始实现，它就会永远继续寻找嵌套键。因此，您可以添加对any 的检查并在这种情况下仅解析为...any[]，这样它就不会陷入无限递归。 playground

type NestedRecord = Record<string, any>

type RecursiveGetIndex<
  TRecord extends NestedRecord,
  TPreviousIndices extends any[] = []
> = {
   // first check for any with 0 extends <clearly not 0> and opt out of recursing with just any nested keys
   // optionally you could use ...unknown[] if you wanted to be safer.
  [K in keyof TRecord]: 0 extends TRecord[K]&1 ? [...TPreviousIndices, K, ...any[]] 
  : TRecord[K] extends NestedRecord
    ? RecursiveGetIndex<
        TRecord[K],
        AppendToTuple<TPreviousIndices,K>
      >
    : AppendToTuple<TPreviousIndices, K>
}[keyof TRecord]


type AppendToTuple<T extends any[], U> = [...T, U] 

type AnIndex = RecursiveGetIndex<{ foo: { bar: number, baz: any}}> 
//   ^? ["foo", "bar"] | ["foo", "baz", ...any[]]

function doSomething<T extends NestedRecord>(arg:T){
    type Nested = RecursiveGetIndex<T>
    const doMore = (n: Nested) => {
        console.log(n) //here n will work a lot like unknown
    }
}