介紹

在 TypeScript 中使用深度嵌套的數(shù)據(jù)結(jié)構(gòu)時，創(chuàng)建實(shí)用程序類型來轉(zhuǎn)換這些結(jié)構(gòu)是一項(xiàng)常見任務(wù)。然而，遞歸類型雖然功能強(qiáng)大，但也面臨著一系列挑戰(zhàn)。

其中一個挑戰(zhàn)是有效控制遞歸深度，以防止類型計(jì)算超出 TypeScript 的能力。本文將探討一種遞增和遞減類型級數(shù)字的常見方法，確定其局限性，并提出一個使用適當(dāng)?shù)倪f增和遞減類型來管理遞歸深度的強(qiáng)大解決方案。

？基本類型級數(shù)字運(yùn)算的問題

為了更好地理解這些限制，讓我們看一下在類型級別遞增或遞減數(shù)字時經(jīng)常使用的簡單方法：

type Prev = [never, 0, 1, 2, 3, 4];
type Next = [1, 2, 3, 4, 5, 6];

type MinusOne = Prev[5]; // ? 4
type PlusOne = Next[5];  // ? 6

？問題場景：深度嵌套的可選屬性

假設(shè)您有一個深度嵌套的對象類型并且想要創(chuàng)建所有
屬性可選，最高可達(dá)指定級別：

type DeepObject = {
  a: number;
  b: {
    c: string;
    d: {
      e: boolean;
      f: {
        g: string;
        h: {
          i: number;
          j: {
            k: string;
          };
        };
      };
    };
  };
};

使用簡單的硬編碼方法，管理屬性變?yōu)榭蛇x的深度將如下所示：

type Prev = [never, 0, 1, 2, 3, 4];

type DeepOptional<
  T,
  Limit extends number = 1
> = Limit extends never
  ? never
  : {
      [K in keyof T]?: T[K] extends object
        ? DeepOptional<T[K], Prev[Limit]>
        : T[K];
    };

說明：

• DeepOptional 使屬性可選達(dá)到 Limit。
• Limit 將用于從靜態(tài)元組中獲取遞減的值。

用法示例：

type NewDeepObject = DeepOptional<DeepObject, 3>;

// Result:
// {
//   a?: number;
//   b?: {
//     c?: string;
//     d?: {
//       e?: boolean;
//       f?: {
//         g: string;
//         h: {
//           i: number;
//           j: {
//             k: string;
//           };
//         };
//       };
//     };
//   };
// };

type NewDeepObject = DeepOptional<DeepObject, 1>;

// Result:
// {
//   a?: number;
//   b?: {
//     c: string;
//     d: {
//       e: boolean;
//       f: {
//         g: string;
//         h: {
//           i: number;
//           j: {
//             k: string;
//           };
//         };
//       };
//     };
//   };
// };

? 這種方法的問題

• 有限范圍：此方法僅與預(yù)定義數(shù)組 Prev 和 Next 一樣靈活。如果需要遞增或遞減超出這些數(shù)組長度的數(shù)字，則必須手動擴(kuò)展它們，這很麻煩且容易出錯。
• 可擴(kuò)展性：隨著您的需求的發(fā)展，管理這些數(shù)組變得越來越復(fù)雜，使得這種方法對于大規(guī)模類型操作來說不切實(shí)際。

？更穩(wěn)健的解決方案：基于元組的增量和減量類型

為了克服預(yù)定義數(shù)組的限制，我們可以使用元組操作來創(chuàng)建動態(tài)擴(kuò)展的類型安全的遞增和遞減操作。

?? 關(guān)鍵構(gòu)建模塊

• Length Utility：獲取元組長度的類型：

type Prev = [never, 0, 1, 2, 3, 4];
type Next = [1, 2, 3, 4, 5, 6];

type MinusOne = Prev[5]; // ? 4
type PlusOne = Next[5];  // ? 6

• TupleOf：生成 N 個元素元組的類型：

type DeepObject = {
  a: number;
  b: {
    c: string;
    d: {
      e: boolean;
      f: {
        g: string;
        h: {
          i: number;
          j: {
            k: string;
          };
        };
      };
    };
  };
};

• Pop Utility：刪除元組最后一個元素的類型：

type Prev = [never, 0, 1, 2, 3, 4];

type DeepOptional<
  T,
  Limit extends number = 1
> = Limit extends never
  ? never
  : {
      [K in keyof T]?: T[K] extends object
        ? DeepOptional<T[K], Prev[Limit]>
        : T[K];
    };

• 遞增和遞減：

type NewDeepObject = DeepOptional<DeepObject, 3>;

// Result:
// {
//   a?: number;
//   b?: {
//     c?: string;
//     d?: {
//       e?: boolean;
//       f?: {
//         g: string;
//         h: {
//           i: number;
//           j: {
//             k: string;
//           };
//         };
//       };
//     };
//   };
// };

type NewDeepObject = DeepOptional<DeepObject, 1>;

// Result:
// {
//   a?: number;
//   b?: {
//     c: string;
//     d: {
//       e: boolean;
//       f: {
//         g: string;
//         h: {
//           i: number;
//           j: {
//             k: string;
//           };
//         };
//       };
//     };
//   };
// };

？應(yīng)用增量和減量：一個實(shí)際示例

讓我們探索如何將這些實(shí)用程序類型應(yīng)用于更復(fù)雜的現(xiàn)實(shí)世界問題：使對象的屬性在一定深度內(nèi)可選。

問題場景：深度嵌套的可選屬性

假設(shè)您有一個深度嵌套的對象類型并且想要創(chuàng)建所有
屬性可選，最高可達(dá)指定級別：

type Length<T extends any[]> = (T extends { length: number } ? T["length"] : never) & number;

使用簡單的硬編碼方法，管理屬性變?yōu)榭蛇x的深度將會很復(fù)雜。以下是類型安全的 DeepOptional 實(shí)用程序如何解決此問題：

實(shí)現(xiàn) DeepOptional

type TupleOf<N extends number, T extends unknown[] = []> = Length<T> extends N
  ? T
  : TupleOf<N, [...T, unknown]>;

說明：

• DeepOptional 使屬性可選達(dá)到 Limit。
• 該類型遞歸地遞增 CurrentLevel 直到與 Limit 匹配，此時停止遞歸并返回 T。
• 增量確保類型安全遞歸，無需手動數(shù)組映射。

用法示例：

type Pop<T extends any[]> = T extends [...infer U, unknown] ? U : never;

?? 結(jié)論

在medusajs，我們致力于尋找最高效和創(chuàng)新的解決方案來克服復(fù)雜的技術(shù)挑戰(zhàn)。通過利用基于元組的增量和減量類型，您可以超越基本類型級操作的限制并創(chuàng)建可擴(kuò)展的、類型安全的實(shí)用程序。此方法不僅簡化了遞歸深度管理，還確保您保持復(fù)雜類型操作所需的靈活性，而不會超出 TypeScript 的類型檢查限制。

以上是掌握 TypeScript 中的遞歸類型：優(yōu)雅地處理深度限制的詳細(xì)內(nèi)容。更多信息請關(guān)注PHP中文網(wǎng)其他相關(guān)文章！