In a TypeScript project with `strictNullChecks` on, a value is declared `string[] | string | null`. Which branch of `if (typeof value === 'object')` does the checker put `null` in, what is the narrowed type there, and how do you exclude it?

## The situation ```ts declare const value: string[] | string | null; if (typeof value === "object") { // value: string[] | null value.length; // error under strictNullChecks: object is possibly null } else { // value: string } ``` The surprising part for most candidates is the true branch. It is not `string[]`. The checker keeps `null` there, and every property access in the branch is rejected. ## Why the checker does this A `typeof` guard is evidence, and the checker only credits it with what the underlying runtime check can actually prove. The runtime check reports the same tag for `null` as for ordinary objects — that is a JavaScript fact the type layer inherits rather than invents. Modelling it any other way would make the type system *lie*: it would report `string[]` for a value that can be `null`, and the resulting crash would be one the compiler had implicitly promised could not happen. So the true branch keeps every constituent whose tag could be `"object"`, and `null` is one of them. This is worth stating explicitly in an interview, because it inverts the usual complaint. The behaviour is not the checker being imprecise; it is the checker refusing to be more confident than the evidence allows. ## The role of strictNullChecks Everything above depends on `strictNullChecks` being on. With it off, `null` and `undefined` are members of every type and are not tracked separately, so the declared type effectively collapses, the true branch reports `string[]`, and nothing complains — right up until the property access throws at runtime. This is the clearest small demonstration of what that flag buys: it is what makes the `null` in the object branch visible at all. ## The three fixes **Add the explicit non-null test.** The idiomatic form puts it first, so the guard reads as one unit: ```ts if (value !== null && typeof value === "object") { value.length; // value: string[] } ``` **Invert the check.** If the union's non-object member is the interesting one, test for it and let the else branch do the work — but note the else branch still contains `null`, so this only helps when you are handling the primitive: ```ts if (typeof value === "string") { value.toUpperCase(); // value: string } ``` **Use a more specific guard.** When what you actually want is the array, `Array.isArray(value)` narrows directly to the array constituent and leaves `null` in the false branch, because its declared predicate says nothing about null: ```ts if (Array.isArray(value)) { value.length; // value: string[] } ``` ## Starting from unknown The same rule shows up in a second place. When the starting type is `unknown` there is no union to filter, so the guard produces a type — and it produces `object | null`, not `object`: ```ts function f(v: unknown) { if (typeof v === "object") { // v: object | null } } ``` This is why the standard shape for validating an unknown payload is `typeof v === "object" && v !== null`, and why skipping the second half produces an error on the very first property access. ## What the guard does not remove One more consequence: the object branch keeps *all* object-like constituents. Arrays, class instances, plain objects and boxed primitives all report the object tag, so a `typeof` guard can never pick one interface out of a union of interfaces. That job belongs to a different guard — a property-presence check, a discriminant, or `instanceof` — and a candidate who reaches for `typeof` to separate two object shapes has misread what the check can prove. ## Interview framing Name the branch (`null` goes with the objects), state the narrowed type, say that `strictNullChecks` is what makes it visible, and give the fix in one breath. The strongest version adds *why*: narrowing credits a guard only with what the runtime check can actually establish, and this check cannot separate null from an object.