null

In TypeScript, null is both a primitive runtime value and a distinct literal type representing the intentional absence of any object value. It explicitly indicates that a variable has been declared and initialized, but currently holds no meaningful data.

The behavior of the null type within the TypeScript type system is fundamentally governed by the strictNullChecks compiler option in tsconfig.json.

Type System Behavior

Strict Null Checks Enabled (strictNullChecks: true)

When strict null checking is enabled, null is treated as a distinct, standalone type. It is only assignable to null, any, unknown, or a union type that explicitly includes null. It cannot be implicitly assigned to other concrete types.

// Explicitly typed as the literal type `null`
let emptyValue: null = null;

// Error: Type 'null' is not assignable to type 'string'.
// let name: string = null; 

// Valid: Using a union type to allow null
let age: number | null = null;

Strict Null Checks Disabled (strictNullChecks: false)

When strict null checking is disabled, null effectively acts as a subtype of all other types (except never). It bypasses type safety, allowing null to be assigned to variables expecting concrete types.

// Valid only when strictNullChecks is false
let username: string = null;
let isActive: boolean = null;

Type Narrowing

Because null is a distinct type in strict mode, TypeScript’s control flow analysis requires explicit type narrowing to safely extract a non-null value from a union type before performing operations on it. Strict equality (=== or !==) is the standard mechanism for this.

function processLength(text: string | null) {
  // Error: Object is possibly 'null'.
  // console.log(text.length); 

  // Type Narrowing via strict inequality
  if (text !== null) {
    // TypeScript narrows 'text' to 'string' in this block
    console.log(text.length); 
  }
}

The Non-Null Assertion Operator (!)

If a developer can guarantee through external means that a value typed with null will not be null at runtime, TypeScript provides the postfix ! operator. This instructs the compiler to strip null and undefined from the type during static analysis.

declare function getIdentifier(): string | null;

let identifier: string | null = getIdentifier();

// The '!' asserts that identifier is strictly 'string' here, bypassing the null check
let exactLength: number = identifier!.length; 

Runtime Type Evaluation Quirk

TypeScript inherits JavaScript’s legacy behavior where the typeof operator applied to null evaluates to "object". TypeScript’s control flow analysis actively accounts for this behavior when narrowing types.

If a union contains types that do not evaluate to "object" (such as string | null), checking for "object" successfully narrows the type to null. However, if the union contains object types (such as { id: number } | null), the typeof check cannot eliminate null, requiring strict equality checks instead.

let data: string | null = null;

if (typeof data === "object") {
  // TypeScript eliminates 'string' (which evaluates to "string") 
  // and narrows 'data' strictly to 'null' here.
  let empty: null = data; 
}

let record: { id: number } | null = null;

if (typeof record === "object") {
  // 'record' remains '{ id: number } | null' because both evaluate to "object" at runtime.
  
  if (record !== null) {
    // 'record' is now narrowed to '{ id: number }'
    console.log(record.id);
  }
}

Master TypeScript with Deep Grasping Methodology!

Learn More