lesson depth
Mastery
not started · 0%

Strict Null Checks & Type Narrowing

Strict null checks, nullish coalescing, optional chaining, type predicates, and assertions.

Freshness: current•14 min read•Software and Web Engineering

Key Learning Outcomes

  • ✓Enforce strict null safety across APIs
  • ✓Write custom type predicates and assertion functions

Mental model

In strict mode (strictNullChecks: true), null and undefined are distinct domain types, eliminating Tony Hoare's "billion-dollar mistake" of unhandled null pointer dereferences.

Nullable Union T
null
Control Flow Branching (if / optional chain)
Custom Type Predicate val is T
Guaranteed Non-Null Type Narrowing
Conceptual teaching model synthesized from:TypeScript 5.4 Language Specification & Type System Mechanics

Theory

TypeScript's control flow engine tracks variable assignments, truthiness checks, equality guards, and custom type predicates (value is User). Custom assertion functions (asserts condition) narrow types in the calling scope by throwing an error if the condition evaluates to false.

typescript(22 lines)
1export interface UserProfile {
2 id: string;
3 email: string;
4 avatarUrl?: string | null;
5}
6
7export function isDefined<T>(val: T | null | undefined): val is T {
8 return val !== null && val !== undefined;
9}
10
11export function assertNonNull<T>(val: T | null | undefined, msg: string): asserts val is T {
12 if (val === null || val === undefined) {
13 throw new Error(`[Assertion Error]: ${msg}`);
14 }
15}
16
17export function processUserAvatar(user: UserProfile): string {
18 const avatar = user.avatarUrl?.trim() ?? "https://cdn.example.com/default-avatar.png";
19 assertNonNull(user.email, "User must have a valid email address");
20 return `${user.email}:${avatar}`;
21}

Alternatives and trade-offs

  • Non-null assertion operator (!): Tells TypeScript value! is non-null without checking. Risky; throws runtime TypeError if wrong.
  • Explicit Type Guards (isDefined): Type-safe runtime check that narrows types automatically.

Failure modes and misconceptions

  1. || vs ?? Operator: The logical OR operator (||) falls back on falsy values ("", 0, false). Nullish coalescing (??) falls back ONLY on null or undefined.
  2. Abusing ! assertion: Using user!.email bypasses type checking without runtime protection.
Reflect before revealing the guide

Decision scenario

Use nullish coalescing (??) when providing fallbacks for missing API string or numeric fields. Avoid the non-null assertion operator (!) in production application code.

Learning outcomes

  • Configure strictNullChecks to eliminate unhandled null pointer bugs.
  • Implement custom type predicates (val is T) for collection filtering.
  • Author scope-narrowing assertion functions (asserts val is T).

Trade-offs

Strict null checking prevents runtime null reference exceptions, but requires explicit guards or default fallbacks whenever handling optional network data.

Prerequisites & Related Concepts (2)

prerequisite
Explore ➔
Python Protocols vs ABCs

Strict Null Checks & Type Narrowing builds directly upon foundational principles established in Python Protocols vs ABCs.

prerequisite
Explore ➔
Raft Consensus Protocol

Raft Consensus Protocol builds directly upon foundational principles established in Strict Null Checks & Type Narrowing.

Private notes

0 words
Back to MapNext: Software Contracts
Next