Mode strict TypeScript : ce qu'active strict: true

Le mode strict, c'est l'option "strict": true du tsconfig.json. Un seul interrupteur pour huit options de vérification des types, qui détectent les any implicites, les null et undefined non vérifiés, les affectations de fonctions dangereuses et les champs de classe non initialisés. Dans TypeScript 7, strict est activé par défaut. Voici à quoi ressemble du code qui le passe :

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 sortie est no user, SyntaxError et 42. Retirez le : number, le ?. ou le test instanceof et le fichier ne compile plus.

L'activer

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

Les options individuelles l'emportent sur strict, dans les deux sens. "strict": true, "strictNullChecks": false garde tout sauf la vérification des null ; "strict": false, "noImplicitAny": true n'active que cette option. strict vous inscrit aussi aux vérifications ajoutées dans les versions futures, puisque les nouvelles options de la famille strict rejoignent le groupe.

Le strict de TypeScript n'a rien à voir avec la directive "use strict" de JavaScript, qui est un mode d'exécution. TypeScript 7 émet toujours "use strict" là où il le faut, et régler alwaysStrict: false provoque l'erreur TS5108 (l'option a été supprimée).

Ce que détecte chaque option

Les deux qui changent le plus de code sont noImplicitAny et strictNullChecks. Ce bloc les enfreint toutes les deux exprès :

// 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));

Il affiche index.ts(2,17): error TS7006: Parameter 'x' implicitly has an 'any' type. et index.ts(11,13): error TS18048: 'user' is possibly 'undefined'. Sans strict, ce code compile puis plante à l'exécution avec TypeError: Cannot read properties of undefined (reading 'name'). Avec strict, le plantage devient une erreur de compilation. Les corrections sont dans le premier bloc de cette page.

strictFunctionTypes : pourquoi elle existe

Une fonction qui ne gère que des chaînes ne doit pas être utilisée là où des nombres peuvent arriver. La vérification ci-dessous est réduite au silence avec @ts-expect-error pour que vous puissiez l'exécuter et voir ce que l'erreur évite :

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
}

Sans le commentaire, l'affectation provoque l'erreur TS2322, Type '(s: string) => void' is not assignable to type 'Handler'., suivie de Types of parameters 's' and 'value' are incompatible. Une exception subsiste volontairement : les paramètres des méthodes déclarées avec la syntaxe de méthode (handle(value: string | number): void dans une interface) sont toujours vérifiés de la façon plus souple, donc shout pourrait être affectée à une telle méthode sans erreur.

strictPropertyInitialization

Chaque champ de classe doit recevoir une valeur dans sa déclaration ou dans le constructeur. Trois façons de satisfaire cette règle :

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);

Sortie :

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

Les propriétés lastLogin et sessionId existent avec la valeur undefined parce que les champs de classe sont de vrais champs JavaScript avec la cible ES2022. Le ! supprime la vérification sans ajouter aucune protection à l'exécution : préférez donc les autres formes. Cette option a besoin de strictNullChecks ; désactiver celle-ci la désactive aussi.

Activer strict dans un projet existant

Passer une grosse base de code en strict d'un coup peut produire des centaines d'erreurs. Comme strict est la valeur par défaut de TypeScript 7, mettre à jour un projet dont le tsconfig.json ne mentionnait jamais strict l'active tout seul ; écrivez "strict": false si vous avez besoin de l'ancien comportement pendant la migration. Une démarche qui garde le build au vert :

1. Ajoutez "strict": true et désactivez les options qui produisent le plus d'erreurs, généralement "strictNullChecks": false et "noImplicitAny": false.
2. Corrigez les erreurs restantes, puis activez une option de plus et recommencez.
3. Pour noImplicitAny, la plupart des corrections sont des annotations de paramètres. Pour strictNullChecks, ajoutez | undefined là où des valeurs peuvent manquer, puis gérez ce cas avec ?., ?? ou un test if.
4. Quand une correction doit attendre, placez // @ts-expect-error avec une raison sur la ligne. Contrairement à @ts-ignore, il signale une erreur dès que le problème a disparu, donc la liste diminue d'elle-même.

N'utilisez pas as any ni ! pour faire taire les erreurs en masse : chacun cache exactement le bug que l'option devait trouver.

Options utiles que strict n'inclut pas

Elles sont séparées parce qu'elles refusent du code souvent correct. Beaucoup de projets les activent quand même.

noUncheckedIndexedAccess est celle qui attrape le plus de vrais bugs. Quand elle est activée :

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);
}

Dans TypeScript 7, tsc --init active noUncheckedIndexedAccess et exactOptionalPropertyTypes dans la configuration qu'il génère, à côté de strict.