TypeScript 严格模式：strict: true 开启了什么

严格模式就是 tsconfig.json 中的 "strict": true 选项。它是八个类型检查选项的总开关，能捕获隐式的 any、未检查的 null 和 undefined、不安全的函数赋值以及未初始化的类字段。在 TypeScript 7 中，strict 默认开启。能通过严格检查的代码是这样的：

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

输出是 no user、SyntaxError 和 42。去掉 : number、?. 或 instanceof 检查中的任何一个，文件就无法编译了。

开启严格模式

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

单独的选项总是优先于 strict，两个方向都一样。"strict": true, "strictNullChecks": false 保留除空值检查以外的一切；"strict": false, "noImplicitAny": true 只开启这一项。strict 还会让你自动获得未来版本新增的检查，因为新的 strict 系列选项都会加入这一组。

TypeScript 的 strict 与 JavaScript 的 "use strict" 指令毫无关系，后者是一种运行时模式。TypeScript 7 会在需要的地方自动生成 "use strict"，而设置 alwaysStrict: false 会报错 TS5108（该选项已被移除）。

每个选项能捕获什么

改动代码最多的两项是 noImplicitAny 和 strictNullChecks。下面这段代码故意同时违反了这两项：

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

它会输出 index.ts(2,17): error TS7006: Parameter 'x' implicitly has an 'any' type. 和 index.ts(11,13): error TS18048: 'user' is possibly 'undefined'.。如果不开启严格模式，这段代码能编译通过，然后在运行时崩溃并报 TypeError: Cannot read properties of undefined (reading 'name')。开启严格模式后，运行时崩溃就变成了编译错误。修复方法就是本页的第一段代码。

strictFunctionTypes：为什么需要它

只能处理字符串的函数，不能用在可能传入数字的地方。下面的检查被 @ts-expect-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
}

去掉这行注释，这个赋值就会报错 TS2322：Type '(s: string) => void' is not assignable to type 'Handler'.，后面跟着 Types of parameters 's' and 'value' are incompatible.。有一个例外是有意保留的：用方法语法声明的方法参数（接口中的 handle(value: string | number): void）仍按较宽松的方式检查，所以把 shout 赋给这样的方法不会报错。

strictPropertyInitialization

每个类字段都必须在声明处或构造函数中获得一个值。有三种方式满足这一要求：

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

输出：

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

lastLogin 和 sessionId 属性存在，值为 undefined，因为在 ES2022 目标下，类字段是真正的 JavaScript 字段。! 会去掉检查，但不提供任何运行时保护，所以优先使用其他写法。这个选项依赖 strictNullChecks，关掉后者它也会一起失效。

在现有项目中开启严格模式

一次性把大型代码库切换到 strict 可能会产生上百个错误。由于 strict 是 TypeScript 7 的默认值，升级一个 tsconfig.json 从未提到 strict 的项目时，它会自动开启；如果迁移期间需要旧的行为，就写上 "strict": false。下面这条路线可以让构建始终保持通过：

1. 加上 "strict": true，并关闭错误最多的几个选项，通常是 "strictNullChecks": false 和 "noImplicitAny": false。
2. 修复剩下的错误，然后再开启一个选项，重复这个过程。
3. 对于 noImplicitAny，大多数修复就是给参数加类型注解。对于 strictNullChecks，在值可能缺失的地方加上 | undefined，再用 ?.、?? 或 if 判断来处理。
4. 暂时没法修的地方，在那一行写上 // @ts-expect-error 并注明原因。与 @ts-ignore 不同，问题消失后它会报错，所以这份清单会自己慢慢变短。

不要用 as any 或 ! 来批量消除错误：每一个都恰好隐藏了该选项本来要找出的 bug。

strict 不包含的实用选项

这些选项是独立的，因为它们会拒绝很多其实正确的代码。不过很多项目还是会开启它们。

noUncheckedIndexedAccess 能捕获最多的真实 bug。开启后：

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

TypeScript 7 中的 tsc --init 会在生成的配置里，在 strict 旁边开启 noUncheckedIndexedAccess 和 exactOptionalPropertyTypes。