TypeScript

string[] and Array<string> are the same type — the bracket form is shorthand for the generic one. They differ only in syntax: readonly attaches to the bracket form (readonly string[]); the generic spelling is ReadonlyArray<string>.

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.

TypeScript compares types by shape, not by declared name. Any value whose type has x and y of type number is accepted for a Point parameter, no matter how it was declared, and extra members do not disqualify it.

That type describes any function taking one number argument and returning a Promise of User. Parameter names inside a function type are labels for readers only — matching is positional, so an implementation may name the parameter anything.

A type alias can name any type — unions, tuples, primitives and types derived from other types — while an interface declares an object type only. Reach for an alias whenever the type is not a plain object shape.

A class declaration creates two separate things: a type named Person that describes instances, and a value named Person that is the constructor. A parameter receiving the class itself must be typed typeof Person, or new (name: string) => Person.

Two interface declarations sharing a name in the same scope merge into one type carrying both sets of members. Repeating a type alias name is a duplicate-identifier error instead: interfaces are open, aliases are closed.

An unconstrained T has no known members, so a.length is an error: "Property 'length' does not exist on type 'T'". Adding <T extends { length: number }> promises every T the caller picks has a numeric length, so the body may read it.

It produces string. keyof T is the union of T's property names, so K is constrained to those names and infers the literal 'name' at this call; the return type T[K] then resolves to that one property's type.

A type-parameter default supplies the type argument when the caller omits it, so writing ApiResult with no argument means ApiResult<unknown>. TypeScript also falls back to the default in a generic call when inference finds no candidate for that parameter.

A type parameter links the argument type to the return type, so the call site keeps the concrete type it passed in and stays type-checked. any turns checking off instead: the result is unchecked and any misuse of it silently compiles.

The <T> declares a type parameter: a placeholder the user of the interface fills in. Writing ApiResponse<User[]> substitutes User[] for T everywhere in the declaration, so res.data has type User[] while status stays number.

Equality against a literal narrows both branches: d is "up" inside the if and "down" | "left" in the else. Comparing d to "top" is a compile error, because the two types have no overlap and the test could never be true.

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.

They are set operations over unions. Exclude<T, U> drops every member of T assignable to U, Extract<T, U> keeps only those members, and NonNullable<T> removes null and undefined from T.

ReturnType<typeof createUser> gives the type. In a type position, typeof turns the value createUser into its function type, which ReturnType then unwraps. ReturnType<createUser> fails because createUser is a value, not a type.

Partial<T> makes every property of T optional, Required<T> makes every property mandatory, and Readonly<T> makes every property read-only. All three keep T's keys and property types, flip one modifier, and disappear when the code is compiled to JavaScript.

Pick<T, K> builds an object type containing only the properties of T named in K; Omit<T, K> contains every property of T except those. Deriving keeps one source of truth, so editing T updates both types automatically.

Record<K, V> builds an object type whose keys come from K and whose values are all V. It is defined as the mapped type { [P in K]: V }, so a string key produces an open index signature while a union of literals produces exactly those required properties.

The declaration option makes tsc emit .d.ts files next to the JavaScript. Compilation erases types, so the .js carries none; the .d.ts is the type-only mirror that gives consumers of the published package autocomplete and type checking.

allowJs admits .js and .jsx files into the TypeScript program so they are resolved, inferred from and emitted — but no errors are reported in them. checkJs additionally turns the type checker on for those JavaScript files.

The compiler looks inside the package first — package.json's types or typings field, or a types condition in its exports map — then falls back to node_modules/@types/lodash. If neither exists, the import carries no type information.

In tsconfig, target sets the language level of the emitted JavaScript syntax, deciding whether things like async/await or optional chaining get rewritten. module sets the output module format, such as CommonJS require and exports or untouched ESM. The two are independent.

import type declares the binding as types only: TypeScript always erases that statement from the emitted JavaScript, and the name cannot be used as a value. A plain import is erased only when the compiler decides nothing in the file uses it at runtime.

abstract on a class blocks creating instances of that class directly. abstract on a member declares a signature with no body that every concrete subclass must supply. TypeScript rejects instantiating the class and rejects a non-abstract subclass that leaves a member unimplemented.

public, the default, allows access from anywhere. private limits access to the body of the declaring class. protected allows the declaring class and its subclasses. All three are checker-only rules that disappear when TypeScript emits JavaScript.

extends is real inheritance: the base class's members come along and the clause survives into the emitted JavaScript. implements is a compile-time-only conformance check that copies nothing and is erased. A class may implement many interfaces but extend only one class.

The annotation itself is gone after compilation. Decorators are ordinary functions that run when the class is defined, so the library records what it needs in a runtime data store at that moment — either from an explicit argument or from compiler-emitted metadata.

An accessibility or readonly modifier on a constructor parameter makes it a parameter property: TypeScript declares a matching class member and assigns the argument to it. Without a modifier the parameter stays an ordinary constructor-local.