Maison interface Web js tutoriel Maîtriser les types récursifs dans TypeScript : gérer les limitations de profondeur avec élégance

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

Nov 23, 2024 am 04:43 AM

Mastering Recursive Types in TypeScript: Handling Depth Limitations Gracefully

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
Copier après la connexion
Copier après la connexion

? 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;
          };
        };
      };
    };
  };
};
Copier après la connexion
Copier après la connexion

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];
    };
Copier après la connexion
Copier après la connexion

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;
//           };
//         };
//       };
//     };
//   };
// };
Copier après la connexion
Copier après la connexion

✋ 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
Copier après la connexion
Copier après la connexion
  • 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;
          };
        };
      };
    };
  };
};
Copier après la connexion
Copier après la connexion
  • 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];
    };
Copier après la connexion
Copier après la connexion
  • 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;
//           };
//         };
//       };
//     };
//   };
// };
Copier après la connexion
Copier après la connexion

? 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;
Copier après la connexion

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]>;
Copier après la connexion

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&lt;T extends any[]&gt; = T extends [...infer U, unknown] ? U : never;
Copier après la connexion

?️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!

Déclaration de ce site Web
Le contenu de cet article est volontairement contribué par les internautes et les droits d'auteur appartiennent à l'auteur original. Ce site n'assume aucune responsabilité légale correspondante. Si vous trouvez un contenu suspecté de plagiat ou de contrefaçon, veuillez contacter admin@php.cn

Article chaud

Combien de temps faut-il pour battre Split Fiction?
3 Il y a quelques semaines By DDD
Repo: Comment relancer ses coéquipiers
3 Il y a quelques semaines By 尊渡假赌尊渡假赌尊渡假赌
Hello Kitty Island Adventure: Comment obtenir des graines géantes
3 Il y a quelques semaines By 尊渡假赌尊渡假赌尊渡假赌
R.E.P.O. Crystals d'énergie expliqués et ce qu'ils font (cristal jaune)
1 Il y a quelques semaines By 尊渡假赌尊渡假赌尊渡假赌

Article chaud

Combien de temps faut-il pour battre Split Fiction?
3 Il y a quelques semaines By DDD
Repo: Comment relancer ses coéquipiers
3 Il y a quelques semaines By 尊渡假赌尊渡假赌尊渡假赌
Hello Kitty Island Adventure: Comment obtenir des graines géantes
3 Il y a quelques semaines By 尊渡假赌尊渡假赌尊渡假赌
R.E.P.O. Crystals d'énergie expliqués et ce qu'ils font (cristal jaune)
1 Il y a quelques semaines By 尊渡假赌尊渡假赌尊渡假赌

Tags d'article chaud

Bloc-notes++7.3.1

Bloc-notes++7.3.1

Éditeur de code facile à utiliser et gratuit

SublimeText3 version chinoise

SublimeText3 version chinoise

Version chinoise, très simple à utiliser

Envoyer Studio 13.0.1

Envoyer Studio 13.0.1

Puissant environnement de développement intégré PHP

Dreamweaver CS6

Dreamweaver CS6

Outils de développement Web visuel

SublimeText3 version Mac

SublimeText3 version Mac

Logiciel d'édition de code au niveau de Dieu (SublimeText3)

Remplacer les caractères de chaîne en javascript Remplacer les caractères de chaîne en javascript Mar 11, 2025 am 12:07 AM

Remplacer les caractères de chaîne en javascript

jQuery Vérifiez si la date est valide jQuery Vérifiez si la date est valide Mar 01, 2025 am 08:51 AM

jQuery Vérifiez si la date est valide

jQuery obtient un rembourrage / marge d'élément jQuery obtient un rembourrage / marge d'élément Mar 01, 2025 am 08:53 AM

jQuery obtient un rembourrage / marge d'élément

10 vaut la peine de vérifier les plugins jQuery 10 vaut la peine de vérifier les plugins jQuery Mar 01, 2025 am 01:29 AM

10 vaut la peine de vérifier les plugins jQuery

10 onglets jQuery Accordion 10 onglets jQuery Accordion Mar 01, 2025 am 01:34 AM

10 onglets jQuery Accordion

Http débogage avec le nœud et le http-console Http débogage avec le nœud et le http-console Mar 01, 2025 am 01:37 AM

Http débogage avec le nœud et le http-console

Tutoriel de configuration de l'API de recherche Google personnalisé Tutoriel de configuration de l'API de recherche Google personnalisé Mar 04, 2025 am 01:06 AM

Tutoriel de configuration de l'API de recherche Google personnalisé

jQuery Ajouter une barre de défilement à div jQuery Ajouter une barre de défilement à div Mar 01, 2025 am 01:30 AM

jQuery Ajouter une barre de défilement à div

See all articles