Unions & Narrowing

TypeScript narrows x to string inside the if branch and to number in the else branch. Only the eight strings typeof can actually return are accepted; comparing against any other string is reported as a comparison with no overlap.

TypeScript widens a literal only for mutable bindings: const greeting = 'hi' keeps the literal type 'hi', while let greeting = 'hi' widens to string since it can be reassigned. Annotate the let to keep a literal type.

TypeScript's postfix ! is the non-null assertion operator: it strips null and undefined from that expression's type and is then erased. The emitted JavaScript contains no check, so a wrong assertion still throws at runtime.

A plain throw only fires at runtime. Passing the value to a parameter typed never makes the compiler check that branch too, so an unhandled union member becomes a build error rather than a production surprise.

The tag must exist on every union member and be typed as a literal — a string, number, boolean or enum-member literal — with a different value per member, so an equality check selects exactly one member.

Comparing the literal tag narrows the value, so inside case 'circle' shape is only the circle member and radius exists. Before the switch it is still the whole union, where one member has no radius.

TypeScript checks only that the asserted type is assignable to the parameter's declared type. It never inspects the body, so a guard that returns true always narrows, and a wrong predicate is an unchecked assertion the compiler trusts.

The return type value is string makes isString a user-defined type guard: it returns an ordinary boolean at runtime, but the compiler treats a true result as proof and narrows value to string inside the if-branch.

A boolean-returning helper narrows nothing by itself. TypeScript 5.5 infers a type predicate for a helper that has no return-type annotation, exactly one return statement, an unmutated parameter, and a body whose result refines that parameter. Annotating : boolean suppresses the inference.

Truthiness narrowing removes only constituents that can never be truthy, so the then-branch is string | number and the else-branch stays string | number | undefined. Since 0 and "" are ordinary values of number and string, the checker sees nothing wrong.

Strict comparisons remove one constituent each: after x === null returns false the type is string | undefined, and after x === undefined it is string | null. The loose form x == null is special-cased to cover both, so its false branch is plain string.

The in operator keeps union members that declare the named property and drops those that do not. When the property is optional, the member can legitimately lack it at runtime, so the checker keeps that member in both branches.

Null lands in the true branch: the checker narrows to string[] | null, because the runtime check it models reports "object" for null. Combine the guard with an explicit non-null check, or test for the primitive member instead.

On the next line value is narrowed to string by the assignment. Assigning 42 is allowed and re-narrows it to number, because number is inside the declared union. Assigning true is an error: the declared type is the ceiling.

Control-flow analysis stops at a function boundary for a binding that is reassignable: the checker cannot prove when the callback runs, so inside it the variable reverts to its declared type. Copy the narrowed value into a const and close over that.

The never parameter accepts only a value the checker proved impossible, which is what turns a forgotten case into a compile error. The never return type is assignable to any declared return type and tells control-flow analysis the call terminates.

It has type never: each case removed one member and nothing is left. Since only never is assignable to never, a default branch that feeds the value somewhere requiring never stops compiling as soon as an unhandled member survives.

A value is User guard returns a boolean and narrows only where that boolean is tested; an asserts value is User guard returns nothing, throws on failure, and narrows the value for all code after the call.

The guard only proves the value is a non-null object with some property named id. Arrays pass, id may be a number, and items and total are never examined — so a trustworthy check must test every declared field, recursively, and array elements one by one.

A boolean return type says nothing about which argument was checked, and the checker never looks inside a called function. Declaring the return type as value is string turns the helper into a type predicate, so callers narrow.

Replace the flag bag with a union tagged by a status literal — idle, loading, success carrying required data, error carrying required error. Combinations like loading-with-an-error stop being constructible, and call sites lose their optional-field guesswork.

A property lives on a mutable object, so the checker will not assume it still holds its checked value whenever the callback later runs. Read it into a local const first, check that const, and call the const inside the callback.

It declares an assertion function: returning normally is the compiler's proof, so from the call onward TypeScript treats value as a string. The body must throw when value is not a string.

Yes. Since TypeScript 4.4 the checker follows a condition stored in a const and re-applies it wherever that const is used, provided the alias is a const without a type annotation and the value it tests is itself effectively constant.

Both operands narrow to what they could share: inside the branch x and y are each string. If the two declared types had no values in common, the comparison would not compile — the checker rejects it as unintentional because the types have no overlap.

It narrows to any[], because the standard library declares the check with the predicate arg is any[]. Every element read out of it is any, so a strict codebase silently loses type safety inside the branch.

Because the guarded branch never falls through. TypeScript analyses the function as a flow graph, and the only path reaching the code after the if is the one where the check was false, so that path carries the narrowing without needing an else.

A declaration-site ! is a definite-assignment assertion: it promises the variable or class field is assigned before it is read, silencing strictPropertyInitialization and used-before-assigned errors. Postfix ! in an expression is a different operator that drops null and undefined at one use site.

Record over the tag union makes one required property per tag, so a missing handler is an error at the object literal that builds the table — reported at declaration, whether or not the table is ever called, and with the missing key named.