TypeScriptのエクスクラメーション（!）: 非nullアサーション

式のあとに付けるエクスクラメーションマーク value! は、非 null アサーション演算子です。型から 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
}

どちらのヘルパーも ! と同じように型を絞り込みますが、仮定が間違っていれば、別の場所での TypeError ではなく、その場で missing HOST が出ます。assertDefined はアサーション関数（asserts value is ...）で、呼び出しのあと、コンパイラーは host を string として扱います。ほかのパターンは 型ガード にあります。

ほかのエクスクラメーションマーク

! は置かれた場所によって意味が変わります:

コンパイル時に消えるのは最初の2つだけです。!value と !!value は実行時に動いて boolean を返します。