Восклицательный знак в TypeScript: оператор non-null (!)

Восклицательный знак после выражения, value!, это оператор утверждения non-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! делает во время выполнения: ничего

! стирается из вывода. Скомпилированный JavaScript для prices.get("coffee")! это просто 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. Обычно лучше перестроить код, например const config = init();, где 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! это стандартная практика, это фреймворк, который заполняет свойство после создания объекта: @ViewChild(...) child!: ChildDirective в Angular (задаётся до запуска 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 выполняются во время работы программы и возвращают boolean.