TypeScript Strict Mode: was strict: true einschaltet

Der Strict Mode ist die Option "strict": true in tsconfig.json. Sie ist ein Schalter für acht Flags der Typprüfung, die implizites any, ungeprüftes null und undefined, unsichere Funktionszuweisungen und nicht initialisierte Klassenfelder finden. In TypeScript 7 ist strict standardmäßig aktiv. So sieht Code aus, der die Prüfung besteht:

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

Die Ausgabe ist no user, SyntaxError und 42. Entfernst du das : number, das ?. oder die Prüfung mit instanceof, kompiliert die Datei nicht mehr.

Einschalten

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

Einzelne Flags haben Vorrang vor strict, in beide Richtungen. "strict": true, "strictNullChecks": false behält alles außer der Null-Prüfung; "strict": false, "noImplicitAny": true schaltet nur diese eine ein. Mit strict bekommst du außerdem Prüfungen, die in künftigen Versionen hinzukommen, da neue Flags der strict-Familie der Gruppe beitreten.

strict in TypeScript hat nichts mit der Direktive "use strict" von JavaScript zu tun, die ein Laufzeitmodus ist. TypeScript 7 erzeugt "use strict" immer dort, wo es nötig ist, und alwaysStrict: false zu setzen ist der Fehler TS5108 (die Option wurde entfernt).

Was jedes Flag findet

Die beiden, die am meisten Code ändern, sind noImplicitAny und strictNullChecks. Dieser Block verletzt absichtlich beide:

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

Er gibt index.ts(2,17): error TS7006: Parameter 'x' implicitly has an 'any' type. und index.ts(11,13): error TS18048: 'user' is possibly 'undefined'. aus. Ohne strict kompiliert das und stürzt dann zur Laufzeit ab mit TypeError: Cannot read properties of undefined (reading 'name'). Mit strict wird der Absturz zu einem Compilerfehler. Die Lösungen stehen im ersten Block dieser Seite.

strictFunctionTypes: warum es das gibt

Eine Funktion, die nur Strings behandelt, darf nicht dort verwendet werden, wo Zahlen ankommen können. Die Prüfung unten ist mit @ts-expect-error stummgeschaltet, damit du sie ausführen und sehen kannst, was der Fehler verhindert:

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
}

Ohne den Kommentar ist die Zuweisung der Fehler TS2322, Type '(s: string) => void' is not assignable to type 'Handler'., gefolgt von Types of parameters 's' and 'value' are incompatible. Eine Ausnahme bleibt bewusst bestehen: Parameter von Methoden, die in Methodensyntax deklariert sind (handle(value: string | number): void in einem Interface), werden weiterhin lockerer geprüft, also ließe sich shout einer solchen Methode ohne Fehler zuweisen.

strictPropertyInitialization

Jedes Klassenfeld muss in seiner Deklaration oder im Konstruktor einen Wert bekommen. Drei Wege, das zu erfüllen:

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

Ausgabe:

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

Die Eigenschaften lastLogin und sessionId existieren mit dem Wert undefined, weil Klassenfelder bei Target ES2022 echte JavaScript-Felder sind. Das ! entfernt die Prüfung, ohne zur Laufzeit etwas abzusichern, bevorzuge also die anderen Formen. Dieses Flag braucht strictNullChecks; schaltest du das ab, ist es ebenfalls aus.

Strict in einem bestehenden Projekt einschalten

Eine große Codebasis auf einen Schlag auf strict umzustellen kann Hunderte Fehler erzeugen. Weil strict in TypeScript 7 der Standard ist, schaltet das Upgrade eines Projekts, dessen tsconfig.json strict nie erwähnt hat, es von selbst ein; schreibe "strict": false, wenn du das alte Verhalten während der Migration brauchst. Ein Weg, bei dem der Build grün bleibt:

1. Füge "strict": true hinzu und schalte die Flags mit den meisten Fehlern ab, meist "strictNullChecks": false und "noImplicitAny": false.
2. Behebe die übrigen Fehler, schalte dann ein weiteres Flag ein und wiederhole.
3. Bei noImplicitAny sind die meisten Lösungen Parameterannotationen. Bei strictNullChecks ergänzt du | undefined, wo Werte fehlen können, und behandelst das dann mit ?., ?? oder einer if-Prüfung.
4. Wo eine Lösung warten muss, setze // @ts-expect-error mit einer Begründung auf die Zeile. Anders als @ts-ignore meldet es einen Fehler, sobald das Problem behoben ist, die Liste schrumpft also von selbst.

Greife nicht zu as any oder !, um Fehler in großer Zahl zum Schweigen zu bringen: Jedes davon verdeckt genau den Bug, für den das Flag eingeführt wurde.

Nützliche Flags, die strict nicht enthält

Diese sind separat, weil sie Code ablehnen, der oft korrekt ist. Viele Projekte schalten sie trotzdem ein.

noUncheckedIndexedAccess findet die meisten echten Bugs. Wenn es aktiv ist:

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 schaltet in TypeScript 7 in der erzeugten Konfiguration noUncheckedIndexedAccess und exactOptionalPropertyTypes ein, neben strict.