strict a fondo: los siete guardianes

En el módulo 1 activaste strict: true y confiaste. Ahora abres esa caja: strict no es un flag, es un interruptor maestro que enciende SIETE comprobaciones, cada una cazando una categoría distinta de bugs. Entenderlas te deja leer los errores de TS con precisión y saber exactamente qué te está protegiendo cada una.

Un interruptor, siete cerraduras

Los siete guardianes de strict

strict: true equivale a activar estos siete flags a la vez:

{
"compilerOptions": {
  // en vez de esto (activarlos uno a uno)...
  "strictNullChecks": true,
  "noImplicitAny": true,
  "strictFunctionTypes": true,
  "strictBindCallApply": true,
  "strictPropertyInitialization": true,
  "noImplicitThis": true,
  "useUnknownInCatchVariables": true,
  "alwaysStrict": true

  // ...escribes solo esto, que los enciende TODOS:
  // "strict": true
}
}

Los dos que más notas ya los conoces del módulo 1: strictNullChecks (el fin del undefined silencioso) y noImplicitAny (nada de any implícito). Los otros cinco trabajan en silencio, y vale la pena saber qué cazan.

Qué previene cada uno

Un ejemplo de un guardián menos conocido

strictPropertyInitialization caza un bug de clases muy común —un campo que crees inicializado pero no lo está:

class Servicio {
private cliente: HttpCliente;   // ❌ con strict: Property 'cliente' has no
                                //    initializer and is not assigned in the constructor.
conectar() {
  this.cliente.get("/datos");   // en JS: cliente es undefined → 💥
}
}

// TS te obliga a una de estas: inicializar en la declaración, en el constructor,
// o marcarlo como opcional (y entonces manejar el undefined):
class ServicioCorrecto {
private cliente: HttpCliente;
constructor(cliente: HttpCliente) {
  this.cliente = cliente;   // ✓ inicializado en el constructor
}
}
type HttpCliente = { get(url: string): void };

Sin strictPropertyInitialization, cliente arrancaría como undefined y conectar() reventaría en runtime —el clásico "olvidé asignarlo en el constructor". Con él, TS te frena antes. Cada uno de los siete guardianes tapa un hueco así.

Mini-reto

Explora tus guardianes: 1) en un proyecto TS con strict: true, escribe una clase con una propiedad no inicializada y observa el error de strictPropertyInitialization; 2) escribe un try/catch y comprueba que error es unknown (no puedes hacer error.message sin estrechar) —eso es useUnknownInCatchVariables; 3) mira tu tsconfig y confirma que un solo "strict": true reemplaza los siete flags. Cada error que veas es un guardián trabajando.

Qué sigue

strict cubre lo esencial, pero TypeScript tiene MÁS chequeos que valen oro y no vienen en strict —los que atrapan índices de array inseguros, variables sin usar y returns olvidados—. La próxima lección te da esa segunda capa de configuración, la que separa un proyecto bueno de uno impecable.