0Pricing
TypeScript Academy · Aula

Evitando operações de tipos dispendiosas

Identifique e corrija tipos profundamente recursivos ou distributivos

Evitando operações de tipos dispendiosas é uma aula grátis de TypeScript Academy no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de TypeScript Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de TypeScript Academy inclui 4 aulas no total.

O que torna uma operação de tipos dispendiosa?

Tipos profundamente recursivos, grandes distribuições de uniões e cadeias complexas de inferência obrigam o TypeScript a instanciar muitas variantes de tipos, causando lentidões exponenciais.

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

Evite uniões excessivamente grandes

Uniões com centenas de membros (por exemplo, provenientes de muitos literais de string) podem tornar a verificação de tipos muito lenta. Considere restringir o domínio ou usar string com validação.

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

Prefira interfaces a aliases de tipos complexos

As interfaces são armazenadas em cache pelo TypeScript de forma mais agressiva do que as interseções complexas de aliases de tipos. Prefira interface para formatos de objetos referenciados muitas vezes.

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

Limite a profundidade da recursão

Tipos condicionais recursivos são poderosos, mas podem atingir o limite de profundidade do TypeScript (normalmente 100 níveis). Adicione um contador de profundidade para interromper o processo antecipadamente.

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

Armazene tipos intermediários em cache

Dê nomes aos tipos intermediários complexos para que o TypeScript possa armazená-los em cache e reutilizá-los, em vez de recalculá-los a cada referência.

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

Evite tipos mapeados profundos em objetos grandes

Aplicar DeepReadonly a um tipo de objeto muito grande faz o TypeScript percorrer recursivamente cada propriedade, o que é dispendioso.

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

Use avaliação tardia de genéricos

Envolver um tipo dispendioso em uma função postergada (um tipo de função que o retorna) adia a avaliação até que o tipo seja realmente necessário.

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

Prefira tipos de retorno explícitos

Anotar explicitamente os tipos de retorno das funções impede que o TypeScript os infira repetidamente em cada ponto de chamada, acelerando a verificação de tipos.

// 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 para verificação paralela

O TypeScript 5.5+ isolatedDeclarations exige tipos de retorno explícitos, permitindo a verificação paralela de arquivos independentes sem inferência completa.

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

Referências de projeto para isolamento

As referências de projeto impedem que o TypeScript verifique os tipos de pacotes inalterados, o que traz o maior ganho de desempenho em monorrepositórios grandes.

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

Recapitulação: evitando tipos dispendiosos

Para manter o TypeScript rápido: evite uniões enormes, armazene tipos intermediários em cache, prefira interfaces a aliases complexos, limite a profundidade da recursão, use tipos de retorno explícitos e isole os pacotes com referências de projeto.

Verificação rápida

Qual abordagem ajuda o TypeScript a armazenar um formato de objeto em cache de maneira mais agressiva?

O que você aprendeu

As operações dispendiosas de tipos do TypeScript incluem uniões grandes, recursão profunda e inferência complexa repetida. Otimize armazenando tipos intermediários em cache, preferindo interfaces, limitando o tamanho das uniões e usando referências de projeto em monorrepositórios.

Perguntas Frequentes

A aula “Evitando operações de tipos dispendiosas” é grátis?

Sim — o texto completo de “Evitando operações de tipos dispendiosas” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de TypeScript Academy, atualize para CoddyKit PRO. O curso de TypeScript Academy inclui 4 aulas no total.

O que vou aprender em “Evitando operações de tipos dispendiosas”?

Identifique e corrija tipos profundamente recursivos ou distributivos Você pratica TypeScript Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar TypeScript Academy?

Nenhuma experiência prévia é necessária. TypeScript Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.

Quanto tempo leva a aula “Evitando operações de tipos dispendiosas”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de TypeScript Academy?

Sim. Cada aula de TypeScript Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Analisando o desempenho de compilações lentas do TypeScript
  2. Evitando operações de tipos dispendiosas
  3. skipLibCheck e declarações isoladas
  4. Verificação de tipos na CI: estratégias e ferramentas
← Voltar para TypeScript Academy