Strict mode trong TypeScript: strict: true bật những gì

Strict mode là tùy chọn "strict": true trong tsconfig.json. Đây là một công tắc cho tám cờ kiểm tra kiểu, bắt các trường hợp any ngầm định, null và undefined không được kiểm tra, phép gán hàm không an toàn và trường của lớp chưa được khởi tạo. Trong TypeScript 7, strict bật mặc định. Code vượt qua được strict trông như thế này:

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

Đầu ra là no user, SyntaxError và 42. Bỏ : number, ?. hoặc phép kiểm tra instanceof là tệp không còn biên dịch được nữa.

Bật strict mode

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

Từng cờ riêng lẻ luôn thắng strict, theo cả hai chiều. "strict": true, "strictNullChecks": false giữ mọi thứ trừ kiểm tra null; "strict": false, "noImplicitAny": true chỉ bật đúng cờ đó. strict cũng tự động bật cho bạn các kiểm tra được thêm vào ở những phiên bản sau, vì các cờ mới thuộc nhóm strict sẽ gia nhập nhóm này.

strict của TypeScript không liên quan gì đến chỉ thị "use strict" của JavaScript, vốn là một chế độ lúc chạy. TypeScript 7 luôn sinh "use strict" ở nơi cần thiết, và đặt alwaysStrict: false là lỗi TS5108 (tùy chọn này đã bị loại bỏ).

Mỗi cờ bắt được lỗi gì

Hai cờ làm thay đổi nhiều code nhất là noImplicitAny và strictNullChecks. Khối code này cố tình vi phạm cả hai:

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

Nó in ra index.ts(2,17): error TS7006: Parameter 'x' implicitly has an 'any' type. và index.ts(11,13): error TS18048: 'user' is possibly 'undefined'. Không có strict, đoạn code này biên dịch được rồi crash lúc chạy với TypeError: Cannot read properties of undefined (reading 'name'). Có strict, lỗi crash đó trở thành lỗi biên dịch. Cách sửa chính là khối code đầu tiên trên trang này.

strictFunctionTypes: vì sao cần nó

Một hàm chỉ xử lý chuỗi không được dùng ở nơi có thể nhận vào số. Phép kiểm tra bên dưới được tắt bằng @ts-expect-error để bạn chạy thử và thấy lỗi này ngăn chặn điều gì:

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
}

Không có dòng chú thích đó, phép gán là lỗi TS2322, Type '(s: string) => void' is not assignable to type 'Handler'., kèm theo Types of parameters 's' and 'value' are incompatible. Vẫn còn một ngoại lệ có chủ đích: tham số của các phương thức khai báo bằng cú pháp phương thức (handle(value: string | number): void bên trong một interface) vẫn được kiểm tra theo cách lỏng hơn, nên shout có thể gán cho phương thức như vậy mà không báo lỗi.

strictPropertyInitialization

Mọi trường của lớp phải nhận giá trị ngay khi khai báo hoặc trong hàm khởi tạo. Có ba cách để thỏa mãn điều này:

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

Đầu ra:

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

Hai thuộc tính lastLogin và sessionId tồn tại với giá trị undefined vì trường của lớp là trường JavaScript thật khi target là ES2022. Dấu ! bỏ phép kiểm tra mà không thêm bất kỳ cơ chế bảo vệ nào lúc chạy, nên hãy ưu tiên các cách còn lại. Cờ này cần strictNullChecks; tắt cờ đó thì cờ này cũng bị tắt theo.

Bật strict trong một dự án có sẵn

Chuyển cả một codebase lớn sang strict cùng lúc có thể sinh ra hàng trăm lỗi. Vì strict là mặc định của TypeScript 7, nâng cấp một dự án mà tsconfig.json chưa từng nhắc đến strict sẽ tự bật nó; hãy viết "strict": false nếu bạn cần giữ hành vi cũ trong lúc chuyển đổi. Một lộ trình giúp bản build luôn thành công:

1. Thêm "strict": true và tắt những cờ gây nhiều lỗi nhất, thường là "strictNullChecks": false và "noImplicitAny": false.
2. Sửa các lỗi còn lại, rồi bật thêm một cờ và lặp lại.
3. Với noImplicitAny, phần lớn cách sửa là thêm chú thích kiểu cho tham số. Với strictNullChecks, thêm | undefined ở nơi giá trị có thể thiếu, rồi xử lý bằng ?., ?? hoặc một câu lệnh if.
4. Ở chỗ chưa thể sửa ngay, đặt // @ts-expect-error kèm lý do trên dòng đó. Khác với @ts-ignore, nó sẽ báo lỗi khi vấn đề đã hết, nên danh sách tự ngắn lại.

Đừng dùng as any hay ! để tắt lỗi hàng loạt: mỗi lần như vậy lại che đúng con bug mà cờ đó được thêm vào để tìm.

Những cờ hữu ích mà strict không bao gồm

Các cờ này tách riêng vì chúng từ chối cả những đoạn code thường là đúng. Dù vậy, nhiều dự án vẫn bật chúng.

noUncheckedIndexedAccess bắt được nhiều bug thật nhất. Khi bật nó:

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 trong TypeScript 7 bật noUncheckedIndexedAccess và exactOptionalPropertyTypes trong tệp cấu hình mà nó tạo ra, bên cạnh strict.