What does strict enable, and why is strictNullChecks the important one?

strict turns on a family of checks at once, and you can switch any member off individually. Per the TSConfig reference it covers:

• strictNullChecks: null and undefined stop being members of every type. They get their own types, so string no longer accepts them.
• noImplicitAny: an untyped parameter or binding that cannot be inferred is an error instead of silently any.
• strictFunctionTypes: function parameters are compared contravariantly. It applies to function-typed properties, not to method syntax.
• strictBindCallApply: call, bind and apply check their arguments against the target function.
• strictPropertyInitialization: a class property must be assigned in the constructor or be typed to allow undefined. It requires strictNullChecks.
• noImplicitThis, useUnknownInCatchVariables (catch variable is unknown), strictBuiltinIteratorReturn (built-in iterators return undefined, not any) and alwaysStrict (parse as ES strict mode and emit "use strict").

strictNullChecks is the important one because it removes the most common runtime crash class: "cannot read properties of undefined". Without it, array.find(...) is typed as returning the element, Map#get returns the value, and optional fields look always present, so the compiler certifies code that throws. With it, every place a value might be absent is visible in the type and you must narrow before use. The other flags tighten how types relate; this one changes what the types mean.

Version note. Before TS 6.0, strict defaulted to false. TS 6.0 made it true by default and TS 7.0 kept that, so a tsconfig without strict is now strict. The reference also warns that future versions may add checks under strict, so upgrades can surface new errors.

For a new project I leave strict on. For a legacy codebase I enable the flags one at a time, strictNullChecks and noImplicitAny first, rather than flipping everything in one commit.

// TypeScript 7.0.2 and 6.0.3, no "strict" key in tsconfig (5.9.3 needs "strict": true)
const users = [{ name: "Oby", age: 12 }];
const found = users.find((u) => u.name === "Heera");
console.log(found.age);
// Error TS18048: 'found' is possibly 'undefined'.
if (found) console.log(found.age); // OK: narrowed to the object

function legacy(s) { return s.length; }
// Error TS7006: Parameter 's' implicitly has an 'any' type.

class Account { email: string; }
// Error TS2564: Property 'email' has no initializer and is not definitely assigned in the constructor.

try { JSON.parse("{"); } catch (e) { console.log(e.message); }
// Error TS18046: 'e' is of type 'unknown'.

With "strict": false, the same file compiled without errors, and running the emitted found.age line threw TypeError: Cannot read properties of undefined (reading 'age') on Node 24.19.0.

• Assuming a missing strict means "off". On 5.9.3 the file above compiled with no errors, on 6.0.3 and 7.0.2 it printed all four. Pin "strict": true or false explicitly in shared base configs.
• Expecting strictFunctionTypes to cover methods. { func(x: string | number): void } still accepted (x: string) => void; the same shape written as a property func: (x: string | number) => void was an error (TS2322).
• Turning on strictPropertyInitialization alone. With strictNullChecks off, tsc reports TS5052: Option 'strictPropertyInitialization' cannot be specified without specifying option 'strictNullChecks'.
• Silencing null errors with ! everywhere. It restores the unchecked behavior one expression at a time and hides the real "can this be absent?" decision.