Maîtriser les types récursifs dans TypeScript : gérer les limitations de profondeur avec élégance

Introduction

Lorsque vous travaillez avec des structures de données profondément imbriquées dans TypeScript, créer des types d'utilitaires pour transformer ces structures est une tâche courante. Cependant, les types récursifs, bien que puissants, comportent leur propre ensemble de défis.

L'un de ces défis consiste à contrôler efficacement la profondeur de récursion pour empêcher le calcul de type de dépasser les capacités de TypeScript. Cet article explorera une approche courante pour incrémenter et décrémenter les nombres au niveau du type, identifiera ses limites et présentera une solution robuste pour gérer la profondeur de récursion à l'aide des types d'incrément et de décrémentation appropriés.

? Le problème avec les opérations numériques de base au niveau du type

Pour mieux comprendre les limites, examinons une approche naïve souvent utilisée lors de l'incrémentation ou de la décrémentation de nombres au niveau du type :

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

? Scénario de problème : propriétés facultatives profondément imbriquées

Supposons que vous ayez un type d'objet profondément imbriqué et que vous souhaitiez tout créer
propriétés facultatives jusqu'à un niveau spécifié :

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

Avec une approche naïve et codée en dur, la gestion de la profondeur à laquelle les propriétés deviennent facultatives ressemblerait à ceci :

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];
    };

Explication :

• DeepOptional rend les propriétés facultatives jusqu'à Limit.
• La Limite sera utilisée pour obtenir la valeur décrémentée du tuple statique.

Exemple d'utilisation :

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;
//           };
//         };
//       };
//     };
//   };
// };

✋ Problèmes avec cette approche

• Plage limitée : cette approche est aussi flexible que les tableaux prédéfinis Prev et Next. Si vous devez incrémenter ou décrémenter des nombres au-delà de la longueur de ces tableaux, vous devez les étendre manuellement, ce qui est fastidieux et sujet aux erreurs.
• Évolutivité : à mesure que vos besoins évoluent, la gestion de ces baies devient de plus en plus complexe, ce qui rend cette approche peu pratique pour les opérations de type à plus grande échelle.

? Une solution plus robuste : les types d'incrémentation et de décrémentation basés sur des tuples

Pour surmonter les limitations des tableaux prédéfinis, nous pouvons utiliser la manipulation de tuples pour créer des opérations d'incrémentation et de décrémentation de type sécurisé qui évoluent dynamiquement.

?️ Éléments de base clés

• Length Utility : Un type pour obtenir la longueur d'un tuple :

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 : Un type qui génère un tuple de N éléments :

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

• Pop Utility : Un type qui supprime le dernier élément d'un tuple :

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];
    };

• Incrémenter et décrémenter :

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;
//           };
//         };
//       };
//     };
//   };
// };

? Appliquer une incrémentation et une décrémentation : un exemple pratique

Explorons comment ces types d'utilitaires peuvent être appliqués à un problème réel plus complexe : rendre les propriétés d'un objet facultatives jusqu'à une certaine profondeur.

Scénario de problème : propriétés facultatives profondément imbriquées

Supposons que vous ayez un type d'objet profondément imbriqué et que vous souhaitiez tout créer
propriétés facultatives jusqu'à un niveau spécifié :

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

Avec une approche naïve et codée en dur, gérer la profondeur à laquelle les propriétés deviennent facultatives serait complexe. Voici comment un utilitaire DeepOptional de type sécurisé peut résoudre ce problème :

Implémentation de DeepOptional

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

Explication :

• DeepOptional rend les propriétés facultatives jusqu'à Limit.
• Le type incrémente CurrentLevel de manière récursive jusqu'à ce qu'il corresponde à Limit, auquel cas il arrête de se répéter et renvoie T.
• L'incrément<CurrentLevel> garantit une récursion de type sécurisé sans mappages de tableaux manuels.

Exemple d'utilisation :

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

?️Conclusion

Chez medusajs, nous nous engageons à trouver les solutions les plus efficaces et innovantes pour surmonter les défis techniques complexes. En tirant parti des types Incrément et Décrément basés sur des tuples, vous pouvez aller au-delà des limites des opérations de base au niveau du type et créer des utilitaires évolutifs et sécurisés. Cette méthode simplifie non seulement la gestion de la profondeur de récursion, mais garantit également que vous conservez la flexibilité nécessaire aux opérations de type complexes sans dépasser les limites de vérification de type de TypeScript.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!