如何在 TypeScript 中创建一个类型来检索对象的所有键

typescript 有一个名为 keyof 的功能，可用于获取对象的键。然而，keyof 运算符仅适用于对象的第一层，当我们想要获取深层的所有键时，事情会变得有点复杂。在这篇文章中，我们将讨论如何实现一个可以深层获取所有键的类型。

问题概述

为了理解我们要解决的问题，让我们从一个例子开始。考虑以下对象：

const obj = {
  a: {
    b: 1,
    c: {
      d: 2,
      e: 3
    }
  },
  f: {
    g: 4
  }
}

如果我们想要获取这个对象的所有键，包括嵌套对象中的键，我们需要一个可以递归遍历该对象并返回所有键的类型。这可能是一项具有挑战性的任务，特别是对于具有多层嵌套的复杂对象。

可能的解决方案

解决此问题的一种方法是使用递归类型定义。 typescript 允许我们使用交集类型定义递归类型。交集类型是表示具有交集中所有类型的所有属性的值的类型。

我们可以定义一个递归类型来表示具有一组键的对象，其中每个键要么是一个原始值，要么是另一个也具有一组键的对象。下面是我们如何定义这种类型：

type deepkeys<t> = t extends object
  ? {
      [k in keyof t]-?: k extends string | number
        ? `${k}` | `${k}.${deepkeys<t>}`
        : never;
    }[keyof t]
  : never;
</t></t>

这个类型定义可能看起来有点复杂，所以让我们把它分解成更小的部分。

类型 deepkeys 是一个条件类型，用于检查输入类型 t 是否为对象。如果 t 是一个对象，我们使用映射类型创建一个与 t 具有相同键的新对象，但值是嵌套对象的键，表示为字符串。如果 t 不是对象，我们返回一个空字符串。

映射类型使用 keyof 运算符来获取对象的键，然后我们使用条件语句来检查每个键是否是字符串或数字。如果键是字符串或数字，我们将其与点和嵌套对象的键连接起来，使用 deepkeys 递归获得。如果密钥不是字符串或数字，我们将返回 never，这意味着密钥无效。

使用类型

现在我们已经定义了 deepkeys 类型，我们可以使用它来获取任何具有嵌套对象的对象的键。这是我们如何使用它的示例：

const obj = {
  a: {
    b: 1,
    c: {
      d: 2,
      e: 3,
    },
  },
  f: {
    g: 4,
  },
  h: undefined,
};

type DeepKeys<t> = T extends object
  ? {
      [K in keyof T]-?: K extends string | number
        ? `${K}` | `${K}.${DeepKeys<t>}`
        : never;
    }[keyof T]
  : never;

function getAllKeys<t extends object>(
  obj: T,
  prefix: string = '',
): DeepKeys<t>[] {
  return Object.entries(obj).reduce((result: string[], [key, value]) =&gt; {
    const newPrefix = prefix ? `${prefix}.${key}` : key;

    return result.concat([
      newPrefix,
      ...(typeof value === 'object' &amp;&amp; value !== null
        ? getAllKeys(value, newPrefix)
        : []),
    ]);
  }, []) as DeepKeys<t>[];
}

const keys = getAllKeys(obj);
console.log(keys); // ["a" | "f" | "h" | "a.b" | "a.c" | "a.c.d" | "a.c.e" | "f.g"]
</t></t></t></t></t>

在此示例中，我们定义了一个名为 getallkeys 的函数，该函数将一个对象作为参数并返回该对象中所有键的数组。我们使用 object.keys 方法获取对象的键，然后将结果转换为 deepkeys 类型，以确保我们获取所有键，包括嵌套对象中的键。

限制

虽然 deepkeys 类型在许多情况下都很有用，但它确实有一些限制。一个限制是它仅适用于深度有限的对象。如果我们有一个无限深度的对象，例如包含对自身的引用的对象，类型定义将导致堆栈溢出错误。

另一个限制是，对于具有多层嵌套的对象，结果类型可能非常复杂，这可能会使其难以使用。在某些情况下，可能需要使用更简单的类型定义或不同的方法来获取对象的键。

结论

在本文中，我们讨论了如何实现一个可以获取对象中所有键（包括嵌套对象中的键）的类型。我们使用递归类型定义来定义 deepkeys 类型，它允许我们递归遍历对象并返回所有键。我们还提供了如何使用 deepkeys 类型获取对象的密钥的示例。

虽然 deepkeys 类型有一些限制，但它可以成为处理具有嵌套对象的对象的有用工具。

如果您发现这有帮助，请考虑 订阅我的时事通讯 以获取更多有关 web 开发的有用文章和工具。感谢您的阅读！