Compilações incrementais e cache em monorepos
Otimize os tempos de compilação com compilação incremental e Turborepo
Compilações incrementais e cache em monorepos é uma aula grátis de TypeScript Academy no CoddyKit. Esta é a aula 4 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 as compilações incrementais são importantes
Em monorrepositórios grandes, recompilar todos os pacotes a cada alteração é lento. As compilações incrementais detectam o que mudou e recompilam apenas os pacotes afetados.
# Without incremental: all 20 packages rebuild every time
# With incremental: only 2 changed packages rebuildModo incremental do TypeScript
Habilite "incremental": true no tsconfig para gerar um arquivo .tsbuildinfo que armazena em cache o estado da compilação anterior para reexecuções rápidas.
{
"compilerOptions": {
"incremental": true,
"tsBuildInfoFile": "./.tsbuildinfo"
}
}tsc --build para referências de projetos
tsc --build é incremental por natureza em espaços de trabalho com referências de projetos — ele acompanha as marcas de tempo e ignora os pacotes que já estão atualizados.
# First build: all packages compiled
tsc --build
# Second build: only changed packages compiled
tsc --build
# [12:00:01 PM] Project 'packages/core' is up to dateArmazenamento em cache com o Turborepo
O Turborepo armazena as saídas das tarefas (como dist/) em cache e as restaura quando as entradas não mudaram — para toda a equipe por meio do cache remoto.
// turbo.json
{
"pipeline": {
"build": {
"dependsOn": ["^build"],
"outputs": ["dist/**", ".tsbuildinfo"]
}
}
}Armazenamento em cache remoto com o Turborepo
Compartilhe o cache de compilação entre máquinas de integração contínua e membros da equipe para que ninguém recompile o que outra pessoa já compilou.
# Link to Vercel remote cache
npx turbo login
npx turbo linkCache de computações do Nx
O Nx oferece um armazenamento em cache semelhante, com análise detalhada dos itens afetados com base no grafo de dependências dos projetos.
# Nx: only test affected projects
npx nx affected --target=test --base=mainEntradas e saídas do cache
Para obter um armazenamento em cache correto, declare todas as entradas (arquivos de origem, variáveis de ambiente) e saídas (diretórios dist, tsbuildinfo) na configuração da ferramenta de compilação.
// turbo.json with inputs
{
"pipeline": {
"build": {
"inputs": ["src/**", "tsconfig.json"],
"outputs": ["dist/**"]
}
}
}Invalidando o cache
Os caches são invalidados quando as entradas mudam. Evite incluir arquivos voláteis (como registros ou marcas de tempo) como entradas para impedir recompilações desnecessárias.
# Force rebuild even if cached
turbo run build --forceIntegração com CI
Conecte a integração contínua (GitHub Actions, CircleCI) ao cache remoto para que as compilações de PR sejam rápidas, reutilizando artefatos de compilação anteriores.
# .github/workflows/ci.yml
- name: Build
run: npx turbo build
env:
TURBO_TOKEN: ${{ secrets.TURBO_TOKEN }}
TURBO_TEAM: my-teamApenas verificação incremental de tipos
Use tsc --noEmit --incremental para obter etapas rápidas de integração contínua que verificam apenas os tipos, ignoram a emissão e ainda se beneficiam do armazenamento em cache.
npx tsc --noEmit --incremental
# Quick type check with .tsbuildinfo cacheRecapitulação: compilações incrementais
As compilações incrementais em monorrepositórios usam tsBuildInfo + tsc --build do TypeScript, combinados com o armazenamento em cache do Turborepo ou do Nx, para minimizar o trabalho de compilação a cada alteração.
Verificação rápida
Qual arquivo o TypeScript gera para habilitar compilações incrementais?
O que você aprendeu
As compilações incrementais usam o arquivo .tsbuildinfo do TypeScript e tsc --build para ignorar pacotes inalterados. O Turborepo e o Nx ampliam esse recurso com armazenamento em cache remoto e análise somente dos itens afetados em todo o monorrepositório.
Perguntas Frequentes
A aula “Compilações incrementais e cache em monorepos” é grátis?
Sim — o texto completo de “Compilações incrementais e cache em monorepos” é 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 “Compilações incrementais e cache em monorepos”?
Otimize os tempos de compilação com compilação incremental e Turborepo 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 4 de 4.
Quanto tempo leva a aula “Compilações incrementais e cache em monorepos”?
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
- Referências de projetos TypeScript explicadas
- Workspaces pnpm com TypeScript
- Estratégia para um pacote de tipos compartilhados
- Compilações incrementais e cache em monorepos