TypeScript Type System FAQ & Answers

Control flow analysis (CFA) narrows types based on code structure. After if (typeof x === 'string'), TypeScript knows x is string in that branch. CFA handles: typeof checks, instanceof, truthiness, equality (===, !==), in operator, discriminated unions. TypeScript builds a control flow graph during binding, then lazily evaluates types from this graph when needed. Works backward from variable reference to root.

Type guards are expressions that narrow types in their scope. Built-in: typeof x === 'string' (primitives), x instanceof MyClass (classes), 'prop' in obj (property check), x === null (equality). Custom: functions returning x is Type (type predicates). After a type guard, TypeScript knows the narrowed type in that branch. Use type guards to handle union types safely.

Type predicates are functions returning parameterName is Type. Example: function isString(x: unknown): x is string { return typeof x === 'string'; }. When used in conditionals, TypeScript narrows the type. As of TS 4.9+, TypeScript can infer type predicates in some cases, but explicit predicates are still needed for complex logic. The predicate must be true when returned, or runtime/compile-time mismatch occurs.

Discriminated unions have a common property with literal types (the 'discriminant') unique to each member. Example: type Result = { status: 'success'; data: T } | { status: 'error'; error: Error }. Checking result.status === 'success' narrows to the success variant. Use for: messaging schemes, state management mutations, API responses, finite state machines. Always check the discriminant property.

When narrowing exhausts all union members, the remaining type is never. Use this for exhaustive switch statements: after handling all cases, the default should receive never. If you add a new union member and forget to handle it, TypeScript errors because the new type can't assign to never. Pattern: const _exhaustive: never = value; in default case throws compile error on unhandled variants.

Assertion functions throw if a condition isn't met, narrowing types in the process. Signature: function assert(condition: unknown): asserts condition. After assert(x !== null), TypeScript knows x isn't null. Can also assert specific types: asserts value is string. Unlike type predicates (return boolean), assertion functions throw on failure. Use for validation functions where failure should halt execution.

Control flow analysis (CFA) narrows types based on code structure. After if (typeof x === 'string'), TypeScript knows x is string in that branch. CFA handles: typeof checks, instanceof, truthiness, equality (===, !==), in operator, discriminated unions. TypeScript builds a control flow graph during binding, then lazily evaluates types from this graph when needed. Works backward from variable reference to root.

Type guards are expressions that narrow types in their scope. Built-in: typeof x === 'string' (primitives), x instanceof MyClass (classes), 'prop' in obj (property check), x === null (equality). Custom: functions returning x is Type (type predicates). After a type guard, TypeScript knows the narrowed type in that branch. Use type guards to handle union types safely.

Type predicates are functions returning parameterName is Type. Example: function isString(x: unknown): x is string { return typeof x === 'string'; }. When used in conditionals, TypeScript narrows the type. As of TS 4.9+, TypeScript can infer type predicates in some cases, but explicit predicates are still needed for complex logic. The predicate must be true when returned, or runtime/compile-time mismatch occurs.

Discriminated unions have a common property with literal types (the 'discriminant') unique to each member. Example: type Result = { status: 'success'; data: T } | { status: 'error'; error: Error }. Checking result.status === 'success' narrows to the success variant. Use for: messaging schemes, state management mutations, API responses, finite state machines. Always check the discriminant property.

When narrowing exhausts all union members, the remaining type is never. Use this for exhaustive switch statements: after handling all cases, the default should receive never. If you add a new union member and forget to handle it, TypeScript errors because the new type can't assign to never. Pattern: const _exhaustive: never = value; in default case throws compile error on unhandled variants.

Assertion functions throw if a condition isn't met, narrowing types in the process. Signature: function assert(condition: unknown): asserts condition. After assert(x !== null), TypeScript knows x isn't null. Can also assert specific types: asserts value is string. Unlike type predicates (return boolean), assertion functions throw on failure. Use for validation functions where failure should halt execution.

Strict mode ("strict": true in tsconfig) enables a bundle of stricter type-checking flags: noImplicitAny, strictNullChecks, strictFunctionTypes, strictBindCallApply, strictPropertyInitialization, noImplicitThis, useUnknownInCatchVariables, alwaysStrict. Recommended for all new projects. Catches potential errors at compile time. Explicitly listing flags is redundant but documents intent.

noImplicitAny prevents TypeScript from inferring any when it can't determine a type. Without it, function add(a, b) { return a + b; } silently types parameters as any. With it, TypeScript errors requiring explicit types. This eliminates hidden any 'black holes' that disable type checking. You'll only have any where explicitly declared. Essential for real type safety.

strictNullChecks makes null and undefined distinct types, not assignable to other types. Without it, string accepts null. With it, you must use string | null to allow null. Forces explicit handling of nullable values. Catches common runtime errors at compile time: 'Cannot read property of undefined'. Use optional chaining (?.) and nullish coalescing (??) for cleaner null handling.

noUncheckedIndexedAccess (TS 4.1+) adds undefined to indexed access types. With it, arr[0] is T | undefined, not just T. Forces explicit null checks when accessing array/object indices. Catches common 'undefined is not an object' errors. Example: const first = arr[0] requires if (first !== undefined) before use. More strict than strictNullChecks alone.

exactOptionalPropertyTypes (TS 4.4+) distinguishes between missing properties and properties set to undefined. With interface Config { timeout?: number }, normally both {} and { timeout: undefined } are valid. With this flag, only {} is valid - explicit undefined is disallowed. Use timeout?: number | undefined to allow explicit undefined. Catches accidental prop: undefined assignments.

Strict mode ("strict": true in tsconfig) enables a bundle of stricter type-checking flags: noImplicitAny, strictNullChecks, strictFunctionTypes, strictBindCallApply, strictPropertyInitialization, noImplicitThis, useUnknownInCatchVariables, alwaysStrict. Recommended for all new projects. Catches potential errors at compile time. Explicitly listing flags is redundant but documents intent.

noImplicitAny prevents TypeScript from inferring any when it can't determine a type. Without it, function add(a, b) { return a + b; } silently types parameters as any. With it, TypeScript errors requiring explicit types. This eliminates hidden any 'black holes' that disable type checking. You'll only have any where explicitly declared. Essential for real type safety.

strictNullChecks makes null and undefined distinct types, not assignable to other types. Without it, string accepts null. With it, you must use string | null to allow null. Forces explicit handling of nullable values. Catches common runtime errors at compile time: 'Cannot read property of undefined'. Use optional chaining (?.) and nullish coalescing (??) for cleaner null handling.

noUncheckedIndexedAccess (TS 4.1+) adds undefined to indexed access types. With it, arr[0] is T | undefined, not just T. Forces explicit null checks when accessing array/object indices. Catches common 'undefined is not an object' errors. Example: const first = arr[0] requires if (first !== undefined) before use. More strict than strictNullChecks alone.

exactOptionalPropertyTypes (TS 4.4+) distinguishes between missing properties and properties set to undefined. With interface Config { timeout?: number }, normally both {} and { timeout: undefined } are valid. With this flag, only {} is valid - explicit undefined is disallowed. Use timeout?: number | undefined to allow explicit undefined. Catches accidental prop: undefined assignments.

The satisfies operator (TS 4.9+) validates a value matches a type WITHOUT changing its inferred type. const config = { port: 3000 } satisfies Config - TypeScript checks config matches Config, but infers { port: number } (not just Config). Preserves literal types and narrows inference. Compare to : Config annotation which widens to the annotation type.

Use as const satisfies Type to get immutability + type validation + narrow inference. Example: const routes = { home: '/', users: '/users' } as const satisfies Record<string, string>. The object is readonly with literal types ('/'), validated against Record, but keeps the narrow { home: '/'; users: '/users' } type instead of widening to Record. Best of all three features.

as Type (assertion): Forces a type, bypasses some checks, YOU are responsible for type safety. satisfies Type (validation): Checks compatibility, preserves inferred type, TypeScript validates. Use satisfies for: config objects, ensuring implementations match interfaces. Use as for: type casting from any/unknown, when you know more than TypeScript. satisfies is safer - prefer it when possible.

as const makes values deeply readonly with literal types. const arr = [1, 2] as const becomes readonly [1, 2] (tuple with literals) instead of number[]. Properties become readonly, strings become literal types, numbers become literal types. Use for: route definitions, configuration objects, enum alternatives. Preserves exact values for type inference.

The satisfies operator (TS 4.9+) validates a value matches a type WITHOUT changing its inferred type. const config = { port: 3000 } satisfies Config - TypeScript checks config matches Config, but infers { port: number } (not just Config). Preserves literal types and narrows inference. Compare to : Config annotation which widens to the annotation type.

Use as const satisfies Type to get immutability + type validation + narrow inference. Example: const routes = { home: '/', users: '/users' } as const satisfies Record<string, string>. The object is readonly with literal types ('/'), validated against Record, but keeps the narrow { home: '/'; users: '/users' } type instead of widening to Record. Best of all three features.

as Type (assertion): Forces a type, bypasses some checks, YOU are responsible for type safety. satisfies Type (validation): Checks compatibility, preserves inferred type, TypeScript validates. Use satisfies for: config objects, ensuring implementations match interfaces. Use as for: type casting from any/unknown, when you know more than TypeScript. satisfies is safer - prefer it when possible.

as const makes values deeply readonly with literal types. const arr = [1, 2] as const becomes readonly [1, 2] (tuple with literals) instead of number[]. Properties become readonly, strings become literal types, numbers become literal types. Use for: route definitions, configuration objects, enum alternatives. Preserves exact values for type inference.

The infer keyword extracts types within conditional type extends clauses. Pattern: T extends SomeType<infer U> ? U : never. Creates an inline type variable (U) that captures the matched type. Only valid inside extends clause of conditional types. Classic example: type ReturnType<T> = T extends (...args: any[]) => infer R ? R : any - extracts return type R from function type T.

Combine infer with template literals to extract string parts. Example: type Domain<T> = T extends \https://${string}.${infer D}` ? D : never. Given 'https://api.example.com', extracts 'com'. Can recursively parse: type Words = S extends `${infer W} ${infer R}` ? [W, ...Words] : [S]` splits 'hello world' into ['hello', 'world']. Powerful for typed routing, URL parsing, DSLs.