TypeScript as：类型断言与类型转换详解

value as Type 是类型断言：它告诉 TypeScript 把 value 当作 Type 来对待。人们常把它叫作类型转换，但它只是给编译器的一条指令。它会从 JavaScript 输出中擦除，运行时既不转换任何东西，也不检查任何东西。

interface Config {
  port: number;
  host: string;
}

const text = '{"port": 8080, "host": "localhost"}';

// JSON.parse returns any; the assertion gives the result a useful type
const config = JSON.parse(text) as Config;

console.log(config.port + 1);            // 8081
console.log(config.host.toUpperCase());  // LOCALHOST

这是最典型的用法：你对某个值的了解比编译器多（这里是一段 JSON 的结构），于是把它说出来。如果你说错了，没有任何东西会提醒你。下面几节说明这意味着什么，以及什么时候运行时检查是更好的选择。

as 与尖括号语法

同一个断言有两种写法：

const someValue: unknown = "hello";
const a = someValue as string;   // as syntax
const b = <string>someValue;     // angle-bracket syntax, same meaning

尖括号写法不能用在 .tsx 文件中，因为 <string> 会被当作 JSX 标签。处处都用 as，就永远不会遇到这个问题。断言的优先级较低，所以要在后面继续写表达式时，请用括号包起来：(value as string).length。

断言不会转换值

这一点才是真正导致 bug 的地方。断言改变的是编译器对值的认知，而不是值本身：

const input: unknown = "42";

const asserted = input as number;  // compiles: unknown can be asserted to anything
const converted = Number(input);   // an actual conversion

console.log(asserted + 1);   // 421 (string concatenation: it is still "42")
console.log(converted + 1);  // 43
console.log(typeof asserted, typeof converted); // string number

编译器认为 asserted 是 number，所以 asserted + 1 作为算术运算通过了类型检查。但在运行时它仍然是字符串 "42"，JavaScript 做的是字符串拼接。要改变一个值的类型，就要转换它：Number(x)、String(x)、Boolean(x)、BigInt(x)、new Date(x)。字符串转数字 页面对比了这些转换函数。

编译器允许哪些断言

as 并非毫无限制。当一个类型可以赋值给另一个类型时，TypeScript 才允许 x as T：放宽（"a" as string、dog as Animal）和收窄（animal as Dog、unknown as User）都可以。如果两个类型完全没有重叠，它就会拒绝：

// This does not compile: string and number do not overlap.
const input = "42";
const n = input as number;

console.log(n);

编译器报告 index.ts(3,11): error TS2352: Conversion of type 'string' to type 'number' may be a mistake because neither type sufficiently overlaps with the other. If this was intentional, convert the expression to 'unknown' first. 这条消息本身就点出了绕过的办法：input as unknown as number。这个双重断言能通过编译，但在运行时和上面的例子错得一模一样。当你觉得需要它的时候，正确的修复通常是做一次转换（Number(input)）或者换一个类型。

对于对象，重叠规则很宽松。一个对象字面量只要有部分属性就会被接受，as 就是这样悄悄放过不完整的对象的：

interface User {
  name: string;
  email: string;
}

const draft = { name: "Ada" } as User; // compiles: email is missing
const empty = {} as User;              // compiles too

console.log(draft.name);               // Ada
console.log(typeof draft.email);       // undefined, although the type says string
console.log(empty.name?.length);       // undefined

类型注解（const draft: User = { name: "Ada" }）或 satisfies User 都会报告缺少 email（TS2741）。只有当你确实打算稍后补全对象时，才在对象字面量上使用 as；更好的做法是直接构造完整的对象。

as const 不一样

as const 看起来像断言，作用却和放宽相反：它让字面量的类型尽可能窄。字符串保持为字面量类型，数组变成只读元组，对象属性变成 readonly。

const sizes = ["small", "medium", "large"] as const;
type Size = (typeof sizes)[number]; // "small" | "medium" | "large"

const point = { x: 1, y: 2 } as const; // { readonly x: 1; readonly y: 2 }

function isSize(value: string): value is Size {
  return (sizes as readonly string[]).includes(value);
}

console.log(isSize("medium"), isSize("huge")); // true false
console.log(point.x + point.y);                // 3

它是安全的，因为它精确地描述了这个字面量，而不是声称编译器看不到的东西。（isSize 中的 sizes as readonly string[] 是一个放宽断言，同样安全：它让 includes 能接受任意字符串。）更多内容见 字面量类型。

什么时候类型守卫更合适

as 是一种声明，类型守卫是一种检查。在数据从代码外部进入的边界处（JSON、fetch、localStorage、用户输入、消息），这种声明可能是假的，而断言会把边界处一个清晰的错误，变成别处一个令人困惑的错误。

interface Point {
  x: number;
  y: number;
}

function isPoint(v: unknown): v is Point {
  return typeof v === "object" && v !== null &&
    "x" in v && typeof v.x === "number" &&
    "y" in v && typeof v.y === "number";
}

const raw: unknown = JSON.parse('{"x": 3, "y": "4"}');

// With as: compiles, and the bug surfaces later
const p1 = raw as Point;
console.log(p1.x + p1.y); // 34 (a string snuck in)

// With a guard: the bad data is caught where it enters
if (isPoint(raw)) console.log(raw.x + raw.y);
else console.log("invalid point");

几种看起来相似的工具，大致这样区分：

as 仍有两种合理用法：收窄编译器无法追踪的东西（两行之前刚设置的 Map 条目、来自无类型库的值），以及在测试代码中构造不完整的测试数据。让这些断言保持简短，并且紧挨着你能确认声明成立的地方。