


Maîtriser les types récursifs dans TypeScript : gérer les limitations de profondeur avec élégance
Nov 23, 2024 am 04:43 AMIntroduction
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!

Article chaud

Outils chauds Tags

Article chaud

Tags d'article chaud

Bloc-notes++7.3.1
Éditeur de code facile à utiliser et gratuit

SublimeText3 version chinoise
Version chinoise, très simple à utiliser

Envoyer Studio 13.0.1
Puissant environnement de développement intégré PHP

Dreamweaver CS6
Outils de développement Web visuel

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

Sujets chauds

Remplacer les caractères de chaîne en javascript

jQuery Vérifiez si la date est valide

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

10 vaut la peine de vérifier les plugins jQuery

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

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

jQuery Ajouter une barre de défilement à div
