0Pricing
TypeScript Academy · Lección

Compilaciones incrementales y caché en monorepos

Optimice los tiempos de compilación con compilación incremental y Turborepo.

Compilaciones incrementales y caché en monorepos es una lección gratuita de TypeScript Academy en CoddyKit. Esta es la lección 4 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de TypeScript Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de TypeScript Academy incluye 4 lecciones en total.

Por qué son importantes las compilaciones incrementales

En los monorepos grandes, recompilar todos los paquetes con cada cambio es lento. Las compilaciones incrementales detectan qué ha cambiado y solo recompilan los paquetes afectados.

# Without incremental: all 20 packages rebuild every time
# With incremental: only 2 changed packages rebuild

Modo incremental de TypeScript

Habilite "incremental": true en tsconfig para generar un archivo .tsbuildinfo que almacene en caché el estado de la compilación anterior y permita ejecuciones posteriores más rápidas.

{
  "compilerOptions": {
    "incremental": true,
    "tsBuildInfoFile": "./.tsbuildinfo"
  }
}

tsc --build para referencias de proyectos

tsc --build es incremental por naturaleza en los workspaces con referencias de proyectos: realiza un seguimiento de las marcas de tiempo y omite los paquetes que están actualizados.

# 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 date

Almacenamiento en caché con Turborepo

Turborepo almacena en caché las salidas de las tareas, como dist/, y las restaura desde la caché cuando las entradas no han cambiado, incluso entre miembros del equipo mediante una caché remota.

// turbo.json
{
  "pipeline": {
    "build": {
      "dependsOn": ["^build"],
      "outputs": ["dist/**", ".tsbuildinfo"]
    }
  }
}

Caché remota con Turborepo

Comparta la caché de compilación entre las máquinas de CI y los miembros del equipo para que nadie tenga que recompilar lo que otra persona ya ha compilado.

# Link to Vercel remote cache
npx turbo login
npx turbo link

Caché de computación de Nx

Nx ofrece un almacenamiento en caché similar, con un análisis detallado de los elementos afectados basado en el grafo de dependencias del proyecto.

# Nx: only test affected projects
npx nx affected --target=test --base=main

Entradas y salidas de la caché

Para que el almacenamiento en caché sea correcto, declare todas las entradas, como archivos de origen y variables de entorno, y las salidas, como directorios dist y tsbuildinfo, en la configuración de su herramienta de compilación.

// turbo.json with inputs
{
  "pipeline": {
    "build": {
      "inputs": ["src/**", "tsconfig.json"],
      "outputs": ["dist/**"]
    }
  }
}

Invalidación de la caché

Las cachés se invalidan cuando cambian las entradas. Evite incluir archivos variables, como registros o marcas de tiempo, entre las entradas para no provocar recompilaciones innecesarias.

# Force rebuild even if cached
turbo run build --force

Integración con CI

Conecte CI, como GitHub Actions o CircleCI, a la caché remota para que las compilaciones de las solicitudes de incorporación de cambios sean rápidas al reutilizar artefactos de compilaciones anteriores.

# .github/workflows/ci.yml
- name: Build
  run: npx turbo build
  env:
    TURBO_TOKEN: ${{ secrets.TURBO_TOKEN }}
    TURBO_TEAM: my-team

Comprobación incremental de tipos únicamente

Use tsc --noEmit --incremental en los pasos de CI que solo comprueban tipos para acelerarlos: se omite la emisión, pero se sigue aprovechando la caché.

npx tsc --noEmit --incremental
# Quick type check with .tsbuildinfo cache

Resumen: compilaciones incrementales

Las compilaciones incrementales en monorepos combinan tsBuildInfo de TypeScript y tsc --build con la caché de Turborepo o Nx para minimizar el trabajo de compilación con cada cambio.

Comprobación rápida

¿Qué archivo genera TypeScript para habilitar las compilaciones incrementales?

Lo que ha aprendido

Las compilaciones incrementales usan el archivo .tsbuildinfo de TypeScript y tsc --build para omitir los paquetes sin cambios. Turborepo y Nx amplían este mecanismo con caché remota y análisis exclusivo de los elementos afectados en todo el monorepo.

Preguntas frecuentes

¿La lección «Compilaciones incrementales y caché en monorepos» es gratis?

Sí — el texto completo de «Compilaciones incrementales y caché en monorepos» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de TypeScript Academy, actualiza a CoddyKit PRO. El curso de TypeScript Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Compilaciones incrementales y caché en monorepos»?

Optimice los tiempos de compilación con compilación incremental y Turborepo. Practicas TypeScript Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar TypeScript Academy?

No se requiere experiencia previa. TypeScript Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 4 de 4.

¿Cuánto tiempo toma la lección «Compilaciones incrementales y caché en monorepos»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de TypeScript Academy?

Sí. Cada lección de TypeScript Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Explicación de las referencias de proyectos de TypeScript
  2. Espacios de trabajo pnpm con TypeScript
  3. Estrategia para un paquete de tipos compartidos
  4. Compilaciones incrementales y caché en monorepos
← Volver a TypeScript Academy