TypeScript never 类型：穷尽检查与 never 和 void 的区别

never 是没有任何值的类型。返回类型为 never 的函数永远不会正常返回：它要么抛出异常，要么永远运行下去。never 类型的变量标记着不可能执行的代码，正是这一点让穷尽检查成为可能。

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
}

在返回 number 的函数中，return fail(...) 可以编译通过，因为 never 可以赋值给任何类型：never 类型的值永远不会真正出现。

永不返回的函数

有两种函数永远到达不了结尾：总是抛出异常的函数，以及带无限循环的函数。编译器会核实这个声明。标注为 never 的函数如果结尾可达，会报错 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...
  }
}

推断结果因语法而异。只抛出异常的函数声明会被推断为返回 void，而只抛出异常的箭头函数或函数表达式会被推断为 never：

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

只有当被调用的名字带有返回 never 的显式类型时，类型收窄才会把这次调用视为死路：像上面的 fail 那样标注了 : never 的函数声明，或者带类型注解的变量 const fail: (m: string) => never = (m) => { throw new Error(m); }。推断出的 never 不算数，const fail = (m: string): never => ... 也不算，因为这里只标注了箭头函数，而没有标注变量。

never 与 void

实际的区别体现在类型收窄上。在 if (!user) fail("no user") 之后，只有当 fail 返回 never 时，编译器才知道下一行的 user 已经有定义。如果返回 void，编译器会认为执行可以继续。

用 never 做穷尽检查

对联合类型做 switch 时，每个 case 都会收窄这个值。当所有成员都处理完后，default 中剩下的就是 never。把它赋给一个 never 变量，“我处理了所有情况”就变成了编译器会验证的事情：

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

现在给联合类型加上第三个成员，但不加对应的 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'.

错误信息会指出你漏掉的成员。加上 case "triangle": return (shape.base * shape.height) / 2;，代码就又能编译通过了。assertNever 辅助函数是同一检查的可复用形式，它的 throw 在运行时仍然有用：来自 JSON 或旧版客户端的数据可能包含类型上认为不可能出现的 kind。这个模式是 可辨识联合类型 的核心。

收窄到 never

任何类型收窄都会发生同样的事情，不只是 switch。一旦所有可能都被排除，变量的类型就是 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

如果以后把参数放宽为 string | number | boolean | bigint，const nothing: never = x 这一行就会报错，指出需要更新的函数。

never 在联合类型中会消失

never 是值的空集，所以把它加进联合类型不会改变任何东西：string | never 就是 string。条件类型正是这样过滤联合类型的。返回 never 的分支会把那个成员移除：

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> 和 Extract<T, U> 就是这样工作的。在交叉类型中则正好相反：string & never 是 never。

不可能的类型会变成 never

没有任何值能满足的交叉类型会化简为 never：

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

读取 B 值的属性时，错误信息会说明原因：Property 'kind' does not exist on type 'never'. The intersection 'B' was reduced to 'never' because property 'kind' has conflicting types in some constituents. 如果你构建的类型变成了 never，就去找找有哪两个部分相互矛盾。

never、unknown 与 any

unknown 是类型层级的顶端，never 是底端。any 根本不属于这个层级：它会关闭类型检查。