TypeScript 感叹号：非空断言运算符（!）

表达式后面的感叹号 value! 是非空断言运算符。它从类型中去掉 null 和 undefined，所以 number | undefined 可以当作 number 使用。这是对编译器的一个承诺，而不是一次检查：运行时什么也不会发生。

const prices = new Map<string, number>([
  ["tea", 2.5],
  ["coffee", 3.2],
]);

const tea = prices.get("tea");         // number | undefined
const coffee = prices.get("coffee")!;  // number

console.log(coffee.toFixed(2)); // 3.20
console.log(tea!.toFixed(2));   // 2.50: ! works on any expression

没有 ! 时，tea.toFixed(2) 会报错 TS18048：'tea' is possibly 'undefined'。加上它之后，代码能编译通过，因为你告诉了编译器这个键存在。

x! 在运行时做什么：什么都不做

! 会从输出中擦除。prices.get("coffee")! 编译出的 JavaScript 就是 prices.get("coffee")。如果断言是错的，错误会在之后出现，出现在第一个使用这个缺失值的地方：

const prices = new Map<string, number>([["tea", 2.5]]);

try {
  const juice = prices.get("juice")!; // compiles: the ! silences the check
  console.log(juice.toFixed(2));      // TypeError at runtime
} catch (e) {
  console.log((e as Error).message);
}

程序打印 Cannot read properties of undefined (reading 'toFixed')。崩溃发生在 ! 的下一行，而在真实代码中可能远得多：undefined 可能被存进某个对象，然后在另一个文件里出错。正是这段距离让 ! 变得有风险。

明确赋值：let x!: T

同一个符号出现在声明中时，含义与之相关。TypeScript 会跟踪变量是否在读取之前被赋值，但它无法跟踪在另一个函数里完成的赋值：

// This does not compile: TypeScript cannot see the assignment inside init()
let config: { port: number };

function init() {
  config = { port: 8080 };
}

init();
console.log(config.port);

index.ts(9,13): error TS2454: Variable 'config' is used before being assigned.

let config!: { port: number }; 是明确赋值断言，意思是“这个变量会在任何读取之前被赋值”。它能消除错误，但和 x! 有同样的隐患：如果某次跳过了 init()，读取到的就是 undefined。通常更好的做法是调整代码结构，例如让 init 返回这个对象，然后写 const config = init();。

类属性：prop!: T

开启 strictPropertyInitialization（属于 strict 的一部分）后，每个类属性都必须在声明中或构造函数中初始化。否则会得到 TS2564：Property 'socket' has no initializer and is not definitely assigned in the constructor.。当属性稍后由某个方法或框架设置时，prop!: T 让编译器接受它：

class Connection {
  url: string;
  socket!: { send(msg: string): string }; // set in open(), not in the constructor

  constructor(url: string) {
    this.url = url;
  }

  open() {
    this.socket = { send: (msg) => `sent "${msg}" to ${this.url}` };
  }
}

const c = new Connection("ws://example.com");
console.log(c.socket);            // undefined: declared but not set yet
c.open();
console.log(c.socket.send("hi")); // sent "hi" to ws://example.com

第一个 console.log 暴露了其中的空隙：类型说 socket 总是存在，但在 open() 之前它是 undefined。此时调用 c.socket.send 能编译通过，却会抛出异常。如果这个属性确实可能缺失，就声明为 socket?: ... 并检查它，或者在构造函数中创建这个对象。prop! 成为标准做法的主要场景，是在构造之后才填充属性的框架：Angular 的 @ViewChild(...) child!: ChildDirective（在 ngAfterViewInit 运行之前被设置），或者 ORM 的实体类，库在加载一行数据时填充它的各个列（MikroORM 的文档写的是 @Property() title!: string）。

更安全的替代写法

大多数 ! 都可以换成编译器会检查的写法，或者换成在正确位置大声报错的检查：

function must<T>(value: T | null | undefined, what: string): T {
  if (value == null) throw new Error(`missing ${what}`);
  return value;
}

function assertDefined<T>(value: T, what: string): asserts value is NonNullable<T> {
  if (value == null) throw new Error(`missing ${what}`);
}

const env = new Map([["PORT", "8080"]]);

const port = must(env.get("PORT"), "PORT"); // string
console.log(Number(port) + 1);              // 8081

const host = env.get("HOST");
try {
  assertDefined(host, "HOST");
  console.log(host.toUpperCase()); // host is string after the assertion
} catch (e) {
  console.log((e as Error).message); // missing HOST
}

这两个辅助函数都像 ! 一样收窄类型，但错误的假设会当场产生 missing HOST，而不是在别处产生 TypeError。assertDefined 是一个断言函数（asserts value is ...）：调用之后，编译器把 host 当作 string。更多模式见 类型守卫。

其他的感叹号

! 的含义取决于它所在的位置：

只有前两种会在编译时被擦除。!value 和 !!value 在运行时执行，并返回一个布尔值。