In TypeScript, what changes when the strictNullChecks compiler option is turned on, and what must code do differently before it can use a value that might be null or undefined?

## The two modes TypeScript's type layer is erased at compile time: the checker's whole job is to reject programs before they run. `strictNullChecks` decides how the checker models the two "no value" values that JavaScript has, `null` and `undefined`. With the flag **off** (the legacy default for a bare config), `null` and `undefined` belong to every type. `string` means "a string, or null, or undefined", and this compiles: ```ts const name: string = null; // no error without strictNullChecks name.toUpperCase(); // no error either — crashes at runtime ``` That is unsound by design: the annotation promises something the value does not deliver, and the failure surfaces as a `TypeError` in production instead of a red squiggle. With the flag **on**, `null` and `undefined` become ordinary types of their own. They are assignable only to themselves, to `any` and `unknown`, and — in `undefined`'s case — to `void`. The first line above becomes `Type 'null' is not assignable to type 'string'.` ## Writing absence into the type Once absence is no longer free, you say it explicitly: ```ts let middleName: string | undefined; function find(id: string): User | null { /* ... */ } ``` The union is now honest, and the checker holds you to it. Reading a member off `User | null` produces `'user' is possibly 'null'`, because the operation is only valid on one member of the union. ## Satisfying the checker Four everyday moves clear the error, and all of them are ordinary JavaScript the compiler happens to understand: ```ts const user = find(id); if (user !== null) user.email; // narrowing by a check if (!user) return; // early return, then user is User user?.email; // optional chaining → string | undefined const email = user?.email ?? ''; // nullish default → string ``` `?.` short-circuits to `undefined` when the base is `null` or `undefined`; `??` supplies the fallback for exactly those two values (and, unlike `||`, not for `0` or `''`). Both are runtime operators — they are not type-system features — but the checker tracks what they guarantee and narrows the type accordingly. ## Where undefined arrives implicitly Two pieces of everyday syntax add `| undefined` for you under this flag: ```ts function greet(title?: string) { /* title: string | undefined */ } interface Profile { bio?: string } // reading bio gives string | undefined ``` So a codebase that already used optional parameters and optional properties acquires a large number of new errors the day the flag is switched on. That is the flag working, not misbehaving: each one is a place where the code assumed a value that the signature never promised. ## What the flag does not do It does not emit anything. There is no generated null check, no runtime cost, and no reflection — the emitted JavaScript is identical either way. The guarantee is only as good as the types feeding it, which means three things still slip through: - **`any`** switches checking off for the value entirely, null included. - **A type assertion** (`value as string`) is a claim, not a conversion; the compiler performs no check and simply believes you. - **Untyped data at the boundary** — a JSON response typed as `User` because someone wrote `as User` — can contain `null` in any field, and the checker has no way to know. So `strictNullChecks` makes null-safety *provable inside* the typed part of your program, and the boundary where data enters is where you have to do real work: parse and validate, then hand the rest of the program a type that is actually true. ## Practical notes `strictNullChecks` is one of the flags `strict` turns on, so most modern projects have it without naming it. Enabling it on an existing codebase is usually done gradually, because the error count is proportional to how much the code relied on the loose model. And the flag is contagious in a good way: a library compiled with it exposes `.d.ts` files whose unions tell consumers where values can be missing, which is precisely the information the loose mode threw away.