Modo strict en TypeScript: qué activa strict: true

El modo strict es la opción "strict": true de tsconfig.json. Es un único interruptor para ocho opciones de comprobación de tipos que detectan any implícitos, null y undefined sin comprobar, asignaciones de funciones inseguras y campos de clase sin inicializar. En TypeScript 7, strict está activado por defecto. Así es el código que lo supera:

function double(x: number) { // noImplicitAny: x needs a type
  return x * 2;
}

function findUser(id: number): { name: string } | undefined {
  return id === 1 ? { name: "Ada" } : undefined;
}

const user = findUser(2);
console.log(user?.name ?? "no user"); // strictNullChecks: user may be undefined

try {
  JSON.parse("{");
} catch (err) { // useUnknownInCatchVariables: err is unknown
  console.log(err instanceof Error ? err.name : String(err));
}

console.log(double(21));

La salida es no user, SyntaxError y 42. Quita el : number, el ?. o la comprobación con instanceof y el archivo deja de compilar.

Cómo activarlo

{
    "compilerOptions": {
        "strict": true
    }
}

Las opciones individuales ganan a strict, en cualquier dirección. "strict": true, "strictNullChecks": false mantiene todo excepto la comprobación de null; "strict": false, "noImplicitAny": true activa solo esa. strict también te incluye en las comprobaciones que se añadan en versiones futuras, porque las nuevas opciones de la familia strict se suman al grupo.

El strict de TypeScript no tiene nada que ver con la directiva "use strict" de JavaScript, que es un modo de ejecución. TypeScript 7 siempre genera "use strict" donde hace falta, y poner alwaysStrict: false es el error TS5108 (la opción se eliminó).

Qué detecta cada opción

Las dos que más código cambian son noImplicitAny y strictNullChecks. Este bloque incumple las dos a propósito:

// This does not compile: two strict errors.
function double(x) {
  return x * 2;
}

function findUser(id: number): { name: string } | undefined {
  return id === 1 ? { name: "Ada" } : undefined;
}

const user = findUser(2);
console.log(user.name, double(2));

Imprime index.ts(2,17): error TS7006: Parameter 'x' implicitly has an 'any' type. y index.ts(11,13): error TS18048: 'user' is possibly 'undefined'. Sin strict, esto compila y luego falla en tiempo de ejecución con TypeError: Cannot read properties of undefined (reading 'name'). Con strict, el fallo pasa a ser un error de compilación. Las soluciones son el primer bloque de esta página.

strictFunctionTypes: por qué existe

Una función que solo maneja strings no se debe usar donde pueden llegar números. La comprobación de abajo está silenciada con @ts-expect-error para que puedas ejecutarla y ver qué evita el error:

type Handler = (value: string | number) => void;

const shout = (s: string) => console.log(s.toUpperCase());

// @ts-expect-error strictFunctionTypes rejects this assignment
const handle: Handler = shout;

try {
  handle(42); // the type allows a number, shout cannot take one
} catch (e) {
  console.log(e instanceof Error ? e.message : e); // s.toUpperCase is not a function
}

Sin el comentario, la asignación es el error TS2322, Type '(s: string) => void' is not assignable to type 'Handler'., seguido de Types of parameters 's' and 'value' are incompatible. Queda una excepción por diseño: los parámetros de los métodos declarados con sintaxis de método (handle(value: string | number): void dentro de una interfaz) se siguen comprobando de la forma más laxa, así que shout podría asignarse a un método así sin error.

strictPropertyInitialization

Cada campo de clase debe recibir un valor en su declaración o en el constructor. Tres formas de cumplirlo:

class Account {
  owner: string;                  // assigned in the constructor
  balance = 0;                    // initializer
  history: string[] = [];         // initializer
  lastLogin?: Date;               // optional: may stay undefined
  sessionId!: string;             // "!": assigned later, you promise

  constructor(owner: string) {
    this.owner = owner;
  }
}

const a = new Account("Ada");
a.sessionId = "s-1";
console.log(a);

Salida:

Account {
  owner: 'Ada',
  balance: 0,
  history: [],
  lastLogin: undefined,
  sessionId: 's-1'
}

Las propiedades lastLogin y sessionId existen con el valor undefined porque los campos de clase son campos reales de JavaScript con target ES2022. El ! quita la comprobación sin añadir ninguna protección en tiempo de ejecución, así que es preferible usar las otras formas. Esta opción necesita strictNullChecks; si lo desactivas, también se desactiva ella.

Activar strict en un proyecto existente

Pasar un proyecto grande a strict de golpe puede producir cientos de errores. Como strict es el valor por defecto en TypeScript 7, actualizar un proyecto cuyo tsconfig.json nunca mencionó strict lo activa por sí solo; escribe "strict": false si necesitas el comportamiento anterior mientras migras. Un camino que mantiene la compilación en verde:

1. Añade "strict": true y desactiva las opciones con más errores, normalmente "strictNullChecks": false y "noImplicitAny": false.
2. Corrige los errores que quedan, luego activa una opción más y repite.
3. Para noImplicitAny, la mayoría de las correcciones son anotaciones de parámetros. Para strictNullChecks, añade | undefined donde los valores pueden faltar y luego manéjalo con ?., ?? o un if.
4. Cuando una corrección tenga que esperar, pon // @ts-expect-error con un motivo en la línea. A diferencia de @ts-ignore, da un error en cuanto el problema desaparece, así que la lista se reduce sola.

No recurras a as any ni a ! para silenciar errores en masa: cada uno oculta justo el bug que la opción se añadió para encontrar.

Opciones útiles que strict no incluye

Son independientes porque rechazan código que a menudo es correcto. Muchos proyectos las activan de todos modos.

noUncheckedIndexedAccess es la que detecta más bugs reales. Con ella activada:

const scores = [90, 85];
const d: Record<string, number> = {};

const third: number = scores[2]; // error TS2322: Type 'number | undefined' is not assignable to type 'number'.
const c: number = d["x"];        // same error

const safe = scores[2] ?? 0;     // number
for (const s of scores) {        // for...of is not affected: s is number
    console.log(s);
}

tsc --init en TypeScript 7 activa noUncheckedIndexedAccess y exactOptionalPropertyTypes en la configuración que genera, junto a strict.