tsconfig y strict: cuánta red te pone TypeScript

tsc --init te dejó un tsconfig.json con decenas de opciones comentadas. La buena noticia: solo un puñado importa de verdad para empezar, y una las gobierna a todas. Hoy entiendes el archivo que configura tu proyecto y por qué strict: true no es opcional —es la diferencia entre TypeScript de verdad y JavaScript con adornos.

El tablero de control

Las opciones que importan

Un tsconfig.json sano para empezar se ve así —y la mayoría son de sentido común una vez que sabes qué hacen:

{
"compilerOptions": {
  "target": "ES2022",         // a qué versión de JS compilar
  "module": "ESNext",         // qué sistema de módulos usar (import/export)
  "strict": true,             // ⭐ la estrella: activa TODAS las revisiones estrictas
  "noEmit": true,             // solo revisar tipos; el bundler genera el JS
  "esModuleInterop": true,    // interоp cómodo con librerías CommonJS
  "skipLibCheck": true,       // no revisar los tipos de node_modules (más rápido)
  "moduleResolution": "bundler", // cómo encuentra los imports (moderno)
  "outDir": "./dist"          // dónde poner el JS, si lo emites
},
"include": ["src"]            // qué carpetas compilar
}

target y module definen el "sabor" de JavaScript de salida; include dice qué compilar; outDir a dónde va el resultado. Útiles, pero rutinarias. La que te cambia la vida es strict.

strict: el interruptor que lo enciende todo

El bug que strictNullChecks caza

Este es el peligro concreto, el mismo undefined que sufriste en JavaScript —ahora cazado antes de correr:

function primerNombre(usuarios: string[]): string {
const primero = usuarios[0];   // ¿y si el array está vacío?
return primero.toUpperCase();
}

// SIN strictNullChecks: TS calla, y en runtime revienta con [] → undefined.toUpperCase()
// CON strictNullChecks: TS te avisa que 'primero' podría no existir y te OBLIGA a manejarlo:

function primerNombreSeguro(usuarios: string[]): string {
const primero = usuarios[0];
if (primero === undefined) return "sin usuarios";   // TS feliz: cubriste el caso
return primero.toUpperCase();
}

Ese if (primero === undefined) no es burocracia: es exactamente el chequeo que en JavaScript olvidabas y descubrías cuando un usuario sin datos rompía la app. strictNullChecks convierte ese olvido en un error de compilación —imposible de ignorar. La incomodidad de "TS me obliga a chequear" es, literalmente, TS salvándote del bug más común del lenguaje.

Mini-reto

Explora tu tablero: 1) en el proyecto de la lección anterior, abre el tsconfig.json y asegúrate de que "strict": true; 2) escribe una función que acceda a array[0] y lo use, y observa cómo con strict TS te obliga a manejar el posible undefined; 3) cambia strict a false, guarda, y mira cómo el error DESAPARECE —esa desaparición es exactamente la protección que estarías regalando. Vuelve a ponerlo en true.

Qué sigue

Sabes configurar la red. Ahora una sorpresa agradable: TypeScript no te obliga a anotar TODO. En muchísimos casos DEDUCE el tipo solo —y anotar de más es tan malo como no anotar. La próxima lección te enseña la inferencia y la regla de cuándo escribir un tipo y cuándo callarte y dejar que TS lo haga.