0Pricing
TypeScript Academy · Aula

Analisando o desempenho de compilações lentas do TypeScript

Utilize --extendedDiagnostics e --generateTrace para encontrar gargalos

Analisando o desempenho de compilações lentas do TypeScript é uma aula grátis de TypeScript Academy no CoddyKit. Esta é a aula 1 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.

Por que o TypeScript pode ser lento

Tipos condicionais complexos, distribuições de uniões grandes e tipos mapeados profundamente recursivos podem fazer o verificador de tipos do TypeScript ficar drasticamente mais lento em projetos grandes.

// Expensive: distributive conditional on large union
type Slow = LargeUnion extends infer T ? T extends string ? T : never : never;

Sinalizador --extendedDiagnostics

Execute tsc --extendedDiagnostics para ver um detalhamento do tempo de compilação: fases de análise sintática, vinculação, verificação de tipos e emissão.

tsc --extendedDiagnostics 2>&1 | head -40
# Output:
# Files:             212
# Lines:            48320
# Check time:       8.23s  ← focus here

Sinalizador --generateTrace

tsc --generateTrace ./trace produz um arquivo de rastreamento compatível com o Chrome DevTools que pode ser carregado na aba Performance para mostrar quais tipos são dispendiosos.

tsc --generateTrace ./trace-output
# Open trace-output/trace.json in Chrome DevTools > Performance

Analisando o rastreamento

No rastreamento, procure barras horizontais longas que representem instanciações de tipos dispendiosas. O nome do tipo e a localização no código-fonte informam o que deve ser otimizado.

# Common culprits in traces:
# - Recursive mapped types with large inputs
# - Distributive conditionals over 50+ member unions
# - Deep infer chains on complex generics

Sinalizador --listFiles

tsc --listFiles mostra todos os arquivos incluídos na compilação. Pastas grandes de node_modules incluídas acidentalmente são uma causa comum de problemas de desempenho.

tsc --listFiles 2>&1 | grep node_modules | wc -l
# If this is large, check your include/exclude settings

Reduzindo a inclusão de arquivos

Use include e exclude no tsconfig para limitar quais arquivos o TypeScript processa.

{
  "include": ["src/**/*"],
  "exclude": ["node_modules", "dist", "**/*.test.ts"]
}

skipLibCheck para ganhos rápidos

skipLibCheck: true ignora a verificação de tipos de todos os arquivos de declaração .d.ts, o que pode acelerar significativamente a compilação em projetos com muitas dependências.

{
  "compilerOptions": {
    "skipLibCheck": true
  }
}

Isolando tipos dispendiosos

Extraia cálculos de tipos dispendiosos para tipos intermediários nomeados, permitindo que o TypeScript os armazene em cache em vez de recalculá-los em cada ponto de uso.

// Slow: recomputed at each usage
type Result = ComplexUnion extends string ? ComplexUnion : never;

// Fast: cached
type FilteredUnion = ComplexUnion extends string ? ComplexUnion : never;
type Result = FilteredUnion;

Verificando com transpileOnly

No desenvolvimento, use ts-jest ou esbuild com transpileOnly: true para ignorar a verificação de tipos e iterar mais rapidamente. Execute verificações completas de tipos separadamente na integração contínua.

// jest.config.js with ts-jest
{
  transform: {
    "^.+\.tsx?$": ["ts-jest", { diagnostics: false }]
  }
}

Desempenho do editor

As lentidões do servidor de linguagem do TypeScript no VS Code geralmente remontam aos mesmos tipos dispendiosos. Verifique TypeScript: Restart TS Server e o rastreamento de TS do servidor de linguagem.

// VS Code settings.json to enable detailed TS server log:
// "typescript.tsserver.log": "verbose"

Recapitulação: análise de desempenho da compilação

Use --extendedDiagnostics para obter tempos gerais, --generateTrace para análise por tipo e reduza a inclusão de arquivos, os condicionais profundos e as grandes distribuições de uniões para acelerar a compilação.

Verificação rápida

Qual sinalizador gera um arquivo de rastreamento compatível com o Chrome DevTools?

O que você aprendeu

Analise o desempenho da compilação do TypeScript com --extendedDiagnostics e --generateTrace. Reduza o tempo de compilação limitando a inclusão de arquivos, usando skipLibCheck, armazenando tipos intermediários em cache e evitando operações de tipos profundamente recursivas ou distributivas.

Perguntas Frequentes

A aula “Analisando o desempenho de compilações lentas do TypeScript” é grátis?

Sim — o texto completo de “Analisando o desempenho de compilações lentas do TypeScript” é 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 “Analisando o desempenho de compilações lentas do TypeScript”?

Utilize --extendedDiagnostics e --generateTrace para encontrar gargalos 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 1 de 4.

Quanto tempo leva a aula “Analisando o desempenho de compilações lentas do TypeScript”?

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