0Pricing
TypeScript Academy · Lezione

Come evitare operazioni costose sui tipi

Individui e corregga tipi profondamente ricorsivi o distributivi.

Come evitare operazioni costose sui tipi è una lezione TypeScript Academy gratuita su CoddyKit. Questa è la lezione 2 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento TypeScript Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso TypeScript Academy include 4 lezioni in totale.

Che cosa rende costosa un'operazione sui tipi?

I tipi profondamente ricorsivi, le distribuzioni di union di grandi dimensioni e le catene complesse di inferenza con infer obbligano TypeScript a istanziare molte varianti dei tipi, causando rallentamenti esponenziali.

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

Eviti union di dimensioni eccessive

Le union con centinaia di membri, ad esempio quelle create da molti literal stringa, possono rendere molto lento il controllo dei tipi. Valuti la possibilità di restringere il dominio oppure di usare string con una validazione.

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

Preferisca le interfacce agli alias di tipo complessi

TypeScript memorizza nella cache le interfacce in modo più aggressivo rispetto alle intersezioni complesse di alias di tipo. Preferisca interface per le strutture di oggetti a cui si fa riferimento molte volte.

// Slow: recomputed union intersection each time
type BigObject = TypeA & TypeB & TypeC & TypeD;
// Fast: interface (cached)
interface BigObject extends TypeA, TypeB, TypeC, TypeD {}

Limiti la profondità della ricorsione

I conditional type ricorsivi sono potenti, ma possono raggiungere il limite di profondità di TypeScript, in genere 100 livelli. Aggiunga un contatore della profondità per interrompere l'elaborazione in anticipo.

type Flatten<T, Depth extends number[] = []> =
  Depth["length"] extends 10 ? T
  : T extends (infer U)[] ? Flatten<U, [...Depth, 0]>
  : T;

Memorizzi nella cache i tipi intermedi

Assegni un nome ai tipi intermedi complessi, in modo che TypeScript possa memorizzarli nella cache e riutilizzarli invece di ricalcolarli a ogni riferimento.

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

Eviti mapped type profondi su oggetti di grandi dimensioni

L'applicazione di DeepReadonly a un tipo di oggetto molto grande fa sì che TypeScript attraversi ricorsivamente ogni proprietà, con un costo elevato.

// Expensive on 50-property nested objects
type Safe = DeepReadonly<HugeConfig>;
// Better: annotate at creation time with const assertions

Utilizzi la valutazione lazy dei generics

Racchiudere un tipo costoso in un thunk, ovvero un tipo funzione che lo restituisce, rimanda la valutazione finché il tipo non è effettivamente necessario.

// Lazy evaluation via wrapper
type Lazy<T> = () => T;
type ExpensiveLazy = Lazy<DeepReadonly<HugeConfig>>;

Preferisca i tipi restituiti espliciti

Annotare esplicitamente i tipi restituiti dalle funzioni impedisce a TypeScript di inferirli ripetutamente in ogni punto di chiamata, velocizzando il controllo dei tipi.

// 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 per il controllo in parallelo

isolatedDeclarations di TypeScript 5.5+ richiede tipi restituiti espliciti e consente il controllo dei tipi in parallelo per i file indipendenti, senza dover eseguire l'inferenza completa.

// tsconfig.json
{
  "compilerOptions": {
    "isolatedDeclarations": true
  }
}

Riferimenti ai progetti per l'isolamento

I riferimenti ai progetti impediscono a TypeScript di controllare i tipi dei pacchetti invariati: è il vantaggio più significativo nei monorepo di grandi dimensioni.

# With project references:
# tsc --build only recompiles packages whose sources changed
# Unchanged packages: declaration files used directly

Riepilogo: evitare i tipi costosi

Per mantenere veloce TypeScript: eviti le union enormi, memorizzi nella cache i tipi intermedi, preferisca le interfacce agli alias complessi, limiti la profondità della ricorsione, utilizzi tipi restituiti espliciti e isoli i pacchetti con i riferimenti ai progetti.

Verifica rapida

Quale approccio aiuta TypeScript a memorizzare nella cache una struttura di oggetto in modo più aggressivo?

Che cosa ha imparato

Tra le operazioni costose sui tipi di TypeScript rientrano le union di grandi dimensioni, la ricorsione profonda e l'inferenza complessa ripetuta. Ottimizzi memorizzando nella cache i tipi intermedi, preferendo le interfacce, limitando le dimensioni delle union e utilizzando i riferimenti ai progetti per i monorepo.

Domande Frequenti

La lezione «Come evitare operazioni costose sui tipi» è gratuita?

Sì — il testo completo di «Come evitare operazioni costose sui tipi» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso TypeScript Academy, passa a CoddyKit PRO. Il corso TypeScript Academy include 4 lezioni in totale.

Cosa imparerò in «Come evitare operazioni costose sui tipi»?

Individui e corregga tipi profondamente ricorsivi o distributivi. Eserciti TypeScript Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare TypeScript Academy?

Non è richiesta alcuna esperienza precedente. TypeScript Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 2 di 4.

Quanto tempo richiede la lezione «Come evitare operazioni costose sui tipi»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione TypeScript Academy?

Sì. Ogni lezione TypeScript Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. Profilazione della compilazione lenta di TypeScript
  2. Come evitare operazioni costose sui tipi
  3. skipLibCheck e dichiarazioni isolate
  4. Controllo dei tipi in CI: strategie e strumenti
← Torna a TypeScript Academy