Non-null Assertion

The postfix ! operator, formally known as the non-null assertion operator, is a compile-time directive that instructs the TypeScript compiler to remove null and undefined from the type signature of a preceding expression. It effectively overrides the --strictNullChecks compiler flag for that specific evaluation.

Because TypeScript’s type system is erased during transpilation, the ! operator emits no JavaScript code and provides no runtime safety. It is purely a type assertion. If the underlying value evaluates to null or undefined at runtime, the JavaScript engine will still throw a TypeError if a property or method is accessed on it.

Syntax and Type Narrowing

When appended to an identifier or expression, the compiler narrows the union type by excluding nullable types.

declare const identifier: string | null | undefined;

// Type evaluation: string | null | undefined
const strictEvaluation = identifier;

// Type evaluation: string
const assertedEvaluation = identifier!;

It can be chained directly before property access or method invocations to suppress compiler errors regarding potentially undefined objects.

declare const obj: { nested?: { method: () => void } } | null;

// The ! asserts 'obj' is not null, and 'nested' is not undefined
obj!.nested!.method();

Definite Assignment Assertion

When used in variable or property declarations (placed immediately after the identifier and before the type annotation), the ! operator functions as a definite assignment assertion. This instructs the compiler to bypass strict initialization checks (such as --strictPropertyInitialization), asserting that the variable or property will be assigned a value before it is accessed in the execution flow.

class Entity {
    // Suppresses TS2564: Property 'internalId' has no initializer...
    internalId!: number; 
}

// Suppresses TS2454: Variable 'globalState' is used before being assigned.
let globalState!: object;

Master TypeScript with Deep Grasping Methodology!

Learn More