Éviter les opérations de types coûteuses
Identifiez et corrigez les types profondément récursifs ou distributifs
Éviter les opérations de types coûteuses est une leçon TypeScript Academy gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage TypeScript Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours TypeScript Academy comprend 4 leçons au total.
Qu’est-ce qui rend une opération sur les types coûteuse ?
Les types profondément récursifs, les distributions de grandes unions et les chaînes d’inférence complexes obligent TypeScript à instancier de nombreuses variantes de types, ce qui entraîne des ralentissements exponentiels.
// Expensive: distributes over every member of a large union
type FilterStrings<T> = T extends string ? T : never;
type Result = FilterStrings<string | number | boolean | null | undefined | ...>;Évitez les unions trop volumineuses
Les unions comportant des centaines de membres (par exemple, provenant de nombreux littéraux de chaînes) peuvent rendre la vérification des types très lente. Envisagez de restreindre le domaine ou d’utiliser une chaîne de caractères avec validation.
// Expensive
type HugeUnion = "a" | "b" | "c" | /* 200 more ... */ "z";
// Better: string with a runtime check
function isValid(s: string): s is ValidString { return VALID_SET.has(s); }Préférez les interfaces aux alias de types complexes
TypeScript met les interfaces en cache de manière plus agressive que les intersections d’alias de types complexes. Préférez interface pour les structures d’objets référencées de nombreuses fois.
// Slow: recomputed union intersection each time
type BigObject = TypeA & TypeB & TypeC & TypeD;
// Fast: interface (cached)
interface BigObject extends TypeA, TypeB, TypeC, TypeD {}Limitez la profondeur de récursion
Les types conditionnels récursifs sont puissants, mais peuvent atteindre la limite de profondeur de TypeScript (généralement 100 niveaux). Ajoutez un compteur de profondeur pour arrêter le traitement plus tôt.
type Flatten<T, Depth extends number[] = []> =
Depth["length"] extends 10 ? T
: T extends (infer U)[] ? Flatten<U, [...Depth, 0]>
: T;Mettez les types intermédiaires en cache
Donnez un nom aux types intermédiaires complexes afin que TypeScript puisse les mettre en cache et les réutiliser au lieu de les recalculer à chaque référence.
// Before: recomputed at each use
type MyResult<T> = T extends SomeComplex<infer U> ? Transform<U> : never;
// After: split into named intermediates
type ExtractU<T> = T extends SomeComplex<infer U> ? U : never;
type MyResult<T> = Transform<ExtractU<T>>;Évitez les types mappés profonds sur les objets volumineux
Appliquer DeepReadonly à un type d’objet très volumineux oblige TypeScript à parcourir récursivement chaque propriété, ce qui est coûteux.
// Expensive on 50-property nested objects
type Safe = DeepReadonly<HugeConfig>;
// Better: annotate at creation time with const assertionsUtilisez l’évaluation générique différée
Envelopper un type coûteux dans une fonction différée (un type de fonction qui le renvoie) reporte son évaluation jusqu’à ce que le type soit réellement nécessaire.
// Lazy evaluation via wrapper
type Lazy<T> = () => T;
type ExpensiveLazy = Lazy<DeepReadonly<HugeConfig>>;Préférez les types de retour explicites
L’annotation explicite des types de retour des fonctions évite à TypeScript de les déduire à répétition à chaque site d’appel, ce qui accélère la vérification des types.
// Let TypeScript infer (may be slow for complex functions)
function process(data: Input) { return transform(data); }
// Faster: explicit annotation
function process(data: Input): Output { return transform(data); }isolatedDeclarations pour la vérification parallèle
TypeScript 5.5+ isolatedDeclarations exige des types de retour explicites, ce qui permet de vérifier en parallèle les types de fichiers indépendants sans effectuer une inférence complète.
// tsconfig.json
{
"compilerOptions": {
"isolatedDeclarations": true
}
}Références de projets pour l’isolation
Les références de projets empêchent TypeScript de vérifier les types des paquets inchangés, ce qui constitue le gain le plus important pour les grands monodépôts.
# With project references:
# tsc --build only recompiles packages whose sources changed
# Unchanged packages: declaration files used directlyRécapitulatif : éviter les types coûteux
Pour conserver de bonnes performances avec TypeScript : évitez les unions volumineuses, mettez les types intermédiaires en cache, préférez les interfaces aux alias complexes, limitez la profondeur de récursion, utilisez des types de retour explicites et isolez les paquets avec des références de projets.
Vérification rapide
Quelle approche aide TypeScript à mettre plus efficacement en cache la structure d’un objet ?
Ce que vous avez appris
Les opérations coûteuses sur les types TypeScript comprennent les grandes unions, la récursion profonde et l’inférence complexe répétée. Optimisez-les en mettant les types intermédiaires en cache, en préférant les interfaces, en limitant la taille des unions et en utilisant des références de projets pour les monodépôts.
Questions Fréquemment Posées
La leçon « Éviter les opérations de types coûteuses » est-elle gratuite ?
Oui — le texte complet de « Éviter les opérations de types coûteuses » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours TypeScript Academy, passe à CoddyKit PRO. Le cours TypeScript Academy comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Éviter les opérations de types coûteuses » ?
Identifiez et corrigez les types profondément récursifs ou distributifs Tu pratiques TypeScript Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer TypeScript Academy ?
Aucune expérience préalable n'est requise. TypeScript Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.
Combien de temps prend la leçon « Éviter les opérations de types coûteuses » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon TypeScript Academy ?
Oui. Chaque leçon TypeScript Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- Profiler une compilation TypeScript lente
- Éviter les opérations de types coûteuses
- skipLibCheck et déclarations isolées
- Vérification des types en intégration continue : stratégies et outils