Kiểu never trong TypeScript: kiểm tra đầy đủ, never và void

never là kiểu không có giá trị nào. Một hàm có kiểu trả về never không bao giờ trả về bình thường: nó ném lỗi hoặc chạy mãi mãi. Một biến kiểu never đánh dấu đoạn code không thể chạy tới, và chính điều này giúp kiểm tra đầy đủ các trường hợp.

function fail(message: string): never {
  throw new Error(message);
}

function parsePort(text: string): number {
  const n = Number(text);
  if (Number.isInteger(n) && n > 0 && n < 65536) return n;
  return fail(`invalid port: ${text}`); // never is assignable to number
}

console.log(parsePort("8080")); // 8080

try {
  parsePort("http");
} catch (e) {
  console.log((e as Error).message); // invalid port: http
}

return fail(...) biên dịch được trong một hàm trả về number vì never gán được cho mọi kiểu: một giá trị kiểu never không bao giờ thực sự xuất hiện.

Hàm không bao giờ trả về

Có hai loại hàm không bao giờ chạy đến cuối: hàm luôn ném lỗi, và hàm có vòng lặp vô hạn. Trình biên dịch kiểm tra lời khẳng định này. Một hàm được chú thích never mà phần cuối vẫn tới được là lỗi TS2534, A function returning 'never' cannot have a reachable end point.

function fail(message: string): never {
  throw new Error(message);
}

function runForever(): never {
  while (true) {
    // poll, serve requests...
  }
}

Việc suy luận kiểu khác nhau tùy cú pháp. Một khai báo hàm chỉ ném lỗi được suy ra là trả về void, còn một arrow function hay function expression chỉ ném lỗi được suy ra là never:

function f1() { throw new Error("x"); }       // () => void
const f2 = () => { throw new Error("x"); };   // () => never

Việc thu hẹp kiểu chỉ coi một lời gọi là ngõ cụt khi tên được gọi có kiểu tường minh trả về never: một khai báo hàm được chú thích : never, như fail ở trên, hoặc một biến có chú thích kiểu, const fail: (m: string) => never = (m) => { throw new Error(m); }. Kiểu never được suy ra thì không tính, và const fail = (m: string): never => ... cũng không, vì ở đó chỉ arrow function được chú thích còn biến thì không.

never và void

Khác biệt thực tế thể hiện ở việc thu hẹp kiểu. Sau if (!user) fail("no user"), trình biên dịch chỉ biết user đã được định nghĩa ở dòng tiếp theo nếu fail trả về never. Với kiểu trả về void, nó giả định chương trình có thể chạy tiếp.

Kiểm tra đầy đủ với never

Mỗi case của một switch trên union thu hẹp giá trị. Khi mọi thành viên đã được xử lý, thứ còn lại trong default là never. Gán nó cho một biến never biến câu "tôi đã xử lý mọi trường hợp" thành điều trình biên dịch kiểm chứng:

type Shape =
  | { kind: "circle"; radius: number }
  | { kind: "square"; side: number };

function area(shape: Shape): number {
  switch (shape.kind) {
    case "circle":
      return Math.PI * shape.radius ** 2;
    case "square":
      return shape.side ** 2;
    default: {
      const unhandled: never = shape; // shape is never here
      throw new Error(`unknown shape: ${JSON.stringify(unhandled)}`);
    }
  }
}

console.log(area({ kind: "square", side: 3 })); // 9
console.log(area({ kind: "circle", radius: 1 }).toFixed(4)); // 3.1416

Giờ thêm thành viên thứ ba vào union mà không thêm case:

// This does not compile: "triangle" is not handled
type Shape =
  | { kind: "circle"; radius: number }
  | { kind: "square"; side: number }
  | { kind: "triangle"; base: number; height: number };

function assertNever(value: never): never {
  throw new Error(`Unhandled value: ${JSON.stringify(value)}`);
}

function area(shape: Shape): number {
  switch (shape.kind) {
    case "circle":
      return Math.PI * shape.radius ** 2;
    case "square":
      return shape.side ** 2;
    default:
      return assertNever(shape);
  }
}

console.log(area({ kind: "square", side: 3 }));

index.ts(18,26): error TS2345: Argument of type '{ kind: "triangle"; base: number; height: number; }' is not assignable to parameter of type 'never'.

Lỗi nêu đúng tên thành viên bạn đã quên. Thêm case "triangle": return (shape.base * shape.height) / 2; là code biên dịch lại được. Hàm hỗ trợ assertNever là dạng dùng lại được của cùng phép kiểm tra đó, và câu lệnh throw của nó vẫn có ý nghĩa lúc chạy: dữ liệu từ JSON hoặc từ một client cũ có thể chứa một kind mà kiểu cho là không thể có. Mẫu này là xương sống của discriminated union.

Thu hẹp kiểu về never

Điều tương tự xảy ra với mọi kiểu thu hẹp, không chỉ switch. Khi mọi khả năng đã bị loại, biến có kiểu never:

function describe(x: string | number | boolean): string {
  if (typeof x === "string") return `string "${x}"`;
  if (typeof x === "number") return `number ${x}`;
  if (typeof x === "boolean") return `boolean ${x}`;
  const nothing: never = x; // every option handled
  return nothing;
}

console.log(describe("a")); // string "a"
console.log(describe(2));   // number 2
console.log(describe(true)); // boolean true

Nếu sau này bạn mở rộng tham số thành string | number | boolean | bigint, dòng const nothing: never = x sẽ thành lỗi, chỉ ra đúng hàm cần cập nhật.

never biến mất trong union

never là tập giá trị rỗng, nên thêm nó vào một union không thay đổi gì: string | never chỉ là string. Đó là cách conditional type lọc union. Một nhánh trả về never sẽ loại bỏ thành viên đó:

type OnlyStrings<T> = T extends string ? T : never;

type Mixed = "a" | "b" | 1 | 2 | true;
type Letters = OnlyStrings<Mixed>; // "a" | "b"

const ok: Letters = "a";
// @ts-expect-error: Type '1' is not assignable to type 'Letters'.
const bad: Letters = 1;

console.log(ok);

Exclude<T, U> và Extract<T, U> có sẵn hoạt động đúng theo cách này. Trong intersection thì ngược lại: string & never là never.

Kiểu bất khả thi trở thành never

Một intersection mà không giá trị nào thỏa mãn được sẽ rút gọn thành never:

type A = string & number;                   // never
type B = { kind: "a" } & { kind: "b" };     // never

Đọc một thuộc tính của giá trị kiểu B sẽ báo lý do: Property 'kind' does not exist on type 'never'. The intersection 'B' was reduced to 'never' because property 'kind' has conflicting types in some constituents. Khi một kiểu bạn tạo ra hóa ra là never, hãy tìm hai phần mâu thuẫn với nhau.

never, unknown và any

unknown là đỉnh của hệ thống phân cấp kiểu và never là đáy. any hoàn toàn không thuộc hệ thống phân cấp: nó tắt việc kiểm tra.