Basic Types & Annotations

A tuple type fixes both the length and the type of each position: [string, number] accepts exactly two elements, a string then a number. (string | number)[] accepts any number of elements, in any order.

Numeric enum members auto-increment from the previous value, so Up = 1 makes Down 2, Left 3 and Right 4. String members never auto-increment, so any member following a string member must have its own explicit initializer.

A question mark makes the parameter optional: callers may omit it, and inside the body its type includes undefined. Optional parameters must follow all required ones, and a parameter cannot have both a question mark and a default value.

TypeScript infers a return type from the function body, but nothing tells it what callers will pass, so unannotated parameters fall back to the implicit any type, which noImplicitAny rejects. Annotate the inputs; let the body infer the output.

Lowercase string is the primitive type; capitalised String is the standard-library interface describing the boxed wrapper object. A string is assignable to String, but a String is not assignable to string, so always annotate with the lowercase primitives.

TypeScript infers string[] there: a mutable array of widened strings. Adding as const infers readonly ["admin", "user"] instead — a readonly tuple whose elements keep their exact literal types, with fixed length and position.

A literal type's domain is a single value: the type 'GET' accepts only the string 'GET'. A union such as 'GET' | 'POST' | 'DELETE' accepts exactly those three strings and rejects every other string.

any turns off type checking for a value and everything derived from it; unknown accepts any value but permits almost no operations until you narrow or assert it. Use unknown for JSON.parse output, then validate before use.

strictNullChecks gives null and undefined their own types instead of letting them inhabit every other type. A value typed string | undefined must then be narrowed with a check, optional chaining, or a default before it can be used as a string.

mixed is inferred as (string | number)[] and tags as string[]. TypeScript takes the union of the element types and widens literal types, because a mutable array's slots can later be reassigned to any other string.

readonly number[] has the reading methods but not the mutating ones, so every number[] already satisfies it. The reverse assignment would hand push and sort to a value whose owner is relying on it not being mutated, so the compiler rejects it.

Both emit a var plus a self-invoking function that fills an object. Numeric members are written in both directions — name to value and value back to name — so Direction[0] is 'Up'. String members get only the forward entry, so string enums have no reverse lookup.

An enum is one of the few TypeScript constructs that emits runtime code: a real object built by a self-invoking function. A union of string literals emits nothing, so it costs no bytes and works in tools that only strip types.

TypeScript infers the narrow type 42 for const n = 42 and the wider type number for let n = 42. A const can never be reassigned, so the narrow type stays accurate; a let can be, so the compiler widens it to the primitive.

Assert the object with as const so its values keep their literal types, then take an indexed access over its keys: type Status = (typeof STATUS)[keyof typeof STATUS], which is "idle" | "busy". Without as const the values widen and the union collapses to string.

The compiler inferred string for config.method, because an object literal's property is a mutable location and its fresh literal type widens. Fix it by annotating the object with the union, adding as const, or passing 'GET' inline.

A value typed any makes every expression derived from it any as well — property reads, calls, indexing, awaits — so whole branches of code stop being checked, and the failure surfaces at runtime far from the original annotation.

A function expression or arrow function whose body always throws or loops forever infers never. A function declaration with the same body infers void instead, so you must annotate it : never explicitly to get the never return type.

Yes, it compiles. TypeScript still lets any value of type number flow into a numeric enum type, so a number parsed from JSON is accepted unchecked. Only an out-of-range numeric literal is rejected, so validate at the boundary.

A function that ignores trailing parameters can safely stand in for one that receives them, so TypeScript allows fewer parameters but never more. The risk is that a callback silently receives extra arguments it does not expect, which then land in a parameter that has a default.

Annotate the return type when the result should be checked against a contract you chose: exported API, recursive functions, and anywhere a wrong result must be reported at the definition rather than at distant call sites. Let local helpers and callbacks infer.

string | number[] is a union of a string and an array of numbers, because [] binds tighter than |. (string | number)[] is an array whose elements may each be a string or a number, written generically as Array<string | number>.

never is TypeScript's bottom type: no value has it, so nothing can be assigned to a never variable, while a never value is assignable to every other type. It marks code that cannot be reached.

The ? marks an optional element that may be omitted, and reading it yields number | undefined. The ... is a rest element allowing zero or more booleans at the end. Because the rest element makes the size open-ended, length is typed number.

A number[] has unknown length, so the compiler cannot prove the call supplies exactly two arguments and reports that a spread argument must have a tuple type or be passed to a rest parameter. Typing args as the tuple [number, number] fixes the arity and the call compiles.

A const enum emits no object at all: every member reference is replaced by its literal value at the call site, so LogLevel.Warn becomes 2. In exchange you lose the runtime object — no reverse lookup, no iteration, and the enum name is only legal in property or index access positions.

An enum declaration creates its own distinct type whose members are identified by where they were declared, not by their value, so a matching string literal is not assignable to it. A literal union is structural: any value of the right shape belongs.

A default makes the parameter omittable and lets the compiler infer its type from the initializer. mode is inferred as string, not the literal 'fast', because inference widens literals in mutable positions. Inside the body the type excludes undefined.

Both allow the value undefined, but only x?: number lets the caller omit the argument. With x: number | undefined the argument is still required, so the caller must write undefined explicitly. Inside the body both have type number | undefined.