TypeScript Cheat Sheet

Updated 2026-04-27

Next Topic: WebAssembly (Wasm) Cheat Sheet

TypeScript is a typed superset of JavaScript that adds a static type system and compile-time checks while still running as plain JavaScript after compilation. It matters because it lets teams model data shapes, APIs, and module boundaries explicitly, catching many bugs before runtime and improving editor tooling (navigation, refactors, autocomplete). The key mental model is that TypeScript's checking is mostly structural and happens at compile time — your types don't exist at runtime unless you write runtime validation. TypeScript 5.x has added significant capabilities including Stage 3 decorators, explicit resource management (using/await using), the NoInfer<T> utility type, inferred type predicates, and --erasableSyntaxOnly for Node.js type-stripping workflows.

Quick Index160 entries · 15 tables

Mind Map

15 tables, 160 concepts. Select a concept node to jump to its table row.

Preparing mind map...

Table 1: Type Annotations & Primitive Types

Concept	Example	Description
Type annotation	`let n: number = 42`	Explicitly assigns a static type to a variable, parameter, or return value.
Type inference	`const s = "hello"`	Compiler infers a type from an initializer or usage without an annotation.
string	`let name: string = "Ada"`	Primitive text type.
number	`let pi: number = 3.14159`	Primitive floating-point numeric type (JS `number`).
boolean	`let ok: boolean = true`	Primitive true/false type.
bigint	`const id: bigint = 123n`	Primitive for arbitrary-size integers (JS `bigint`).
symbol	`const key: unique symbol = Symbol("k")`	• Primitive for unique identifiers • `unique symbol` supports nominal-like keys.
null & undefined	`let x: string \| undefined`	• Represent absence • require explicit handling under `strictNullChecks`.
any	`let data: any = JSON.parse(text)`	• Disables type checking for the value — escape hatch • avoid in new code.
unknown	`let data: unknown = JSON.parse(text)`	• Safer top type than `any` • must be narrowed before property access or calls.
void	`function log(msg: string): void { console.log(msg) }`	Indicates a function returns no useful value.
never	`function fail(msg: string): never { throw new Error(msg) }`	Indicates no possible value — unreachable code, always-throws, or exhausted union.

Table 2: Object Shapes (Interfaces, Aliases, Properties)

Pattern	Example	Description
Interface	`interface User { id: string; name: string }`	• Named object shape • supports extension and declaration merging.
Type alias	`type User = { id: string; name: string }`	Gives a name to any type expression — primitives, unions, tuples, objects.
Object type literal	`const u: { id: string; name: string } = { id: "1", name: "Ada" }`	Inline property names and types without naming the type.
Optional property	`type User = { name: string; email?: string }`	Marks a property as possibly absent.
Readonly property	`type User = { readonly id: string; name: string }`	Prevents assignment after initialization at the type-checking level.
Extending interfaces	`interface Admin extends User { role: "admin" }`	Builds larger shapes from smaller ones via `extends`.
Index signature	`type Headers = { [name: string]: string }`	Types objects with unknown keys by specifying key/value types.
Call signature	`type Fn = { (x: number): string }`	Describes a callable object that may also carry properties.
Construct signature	`type Ctor = { new (s: string): Date }`	Describes a `new`-able constructor type.
Excess property checks	`const u: User = { id: "1", name: "Ada", extra: 1 }`	Object literals checked for unknown properties when directly assigned to a type.

Table 3: Type Composition (Unions, Intersections, Literals, Enums)

Type	Example	Description
Union type	`type ID = string \| number`	Value can be one of multiple types.
Intersection type	`type WithId = { id: string } & { createdAt: Date }`	Value must satisfy all combined types simultaneously.
Const assertion (`as const`)	`const roles = ["admin", "user"] as const`	Infers the narrowest literal and readonly types for an expression.
String literal type	`type Role = "admin" \| "user"`	Restricts values to specific string constants.
Numeric literal type	`type Dice = 1 \| 2 \| 3 \| 4 \| 5 \| 6`	Restricts values to specific numeric constants.
Tuple type	`const pair: [string, number] = ["a", 1]`	Fixed-length array with positional element types.
Non-null assertion (`!`)	`user!.id`	Asserts a value is not `null`/`undefined` for type checking (erased at runtime).
Enum (string)	`enum Role { Admin = "admin", User = "user" }`	• Members have explicit string values at runtime • more debuggable than numeric enums.
Enum (numeric)	`enum Status { Pending, Done }`	• Named constants that emit a runtime JS object • auto-increments from 0.
Const enum	`const enum Dir { Up, Down }`	• Inlines enum values at emit time — no runtime object • avoid in public declaration files.

Table 4: Functions (Signatures, Generics, Overloads)

Pattern	Example	Description
Function type expression	`type Mapper = (x: number) => string`	Describes a function's parameter and return types as a type alias.
Generic function	`function first<T>(xs: T[]): T { return xs[0] }`	Parameterizes types with `<T>` for reusable, type-safe logic.
Generic constraint	`function len<T extends { length: number }>(x: T) { return x.length }`	Restricts a type parameter with `extends` so required members can be accessed.
Function overloads	`function parse(x: string): number;<br> function parse(x: number): string;<br> function parse(x: string \| number) { return typeof x === "string" ? +x : String(x) }`	Multiple call signatures with one implementation below them.
Optional parameter	`function greet(name?: string) {}`	• Parameter may be omitted • typed as possibly `undefined` inside the function.
Default parameter	`function inc(n: number = 1) { return n + 1 }`	Supplies a default value when the argument is missing or `undefined`.
Rest parameter	`function sum(...ns: number[]) { return ns.reduce((a,b)=>a+b, 0) }`	Collects remaining arguments into a typed array.
Const type parameter	`function identity<const T>(val: T): T { return val }` `identity(["a","b"]) // T inferred as ["a","b"] not string[]`	Infers the narrowest literal type from a call-site argument (TS 5.0+).
Default type parameter	`type ApiResult<T = unknown> = { data: T }`	Provides a fallback when type arguments are not supplied or inferred.
this parameter	`function f(this: Date) { return this.getTime() }`	Fake first parameter to type `this` (erased in output).
Call signature + properties	`type Fn = { (x: string): string; tag: string }`	Models callable values that also carry properties.

Table 5: Classes (Members, Modifiers, Inheritance)

Concept	Example	Description
Class declaration	`class User { constructor(public id: string) {} }`	• Defines fields/methods with type annotations • emits a JS class.
Parameter properties	`class User { constructor(public readonly id: string) {} }`	Shorthand that declares and initializes a member from a constructor parameter.
public / private / protected	`class A { private secret = 1; protected n = 2; public id = "x" }`	• Controls member visibility in type checking • use `#` for hard JS private fields.
readonly fields	`class A { readonly id = "x" }`	Prevents reassignment after construction at the type-checking level.
implements	`class Repo implements Iterable<string> { [Symbol.iterator]() { return [][Symbol.iterator]() } }`	Checks a class satisfies an interface at compile time.
extends (inheritance)	`class B extends A {}`	Subclassing with `super` calls and overriding.
abstract class	`abstract class Base { abstract run(): void }`	• Cannot be instantiated directly • may declare abstract members subclasses must implement.
Method override	`class B extends A { override toString() { return "B" } }`	• Replaces a base member • `override` keyword enforces the base member exists.
Accessors (get/set)	`class A { get x() { return this._x } set x(v: number) { this._x = v } }`	Declares typed property accessors.
Static initialization block	`class C { static count = 0; static { C.count = 1 } }`	Runs complex static setup code with access to private members (TS 4.4+).
noImplicitOverride	`// tsconfig.json<br> { "compilerOptions": { "noImplicitOverride": true } }`	Requires `override` keyword on all overriding members for safer refactors.

Table 6: Narrowing (Type Guards & Control Flow)

Technique	Example	Description
typeof narrowing	`if (typeof x === "string") x.toUpperCase()`	Narrows unions using JS `typeof` checks.
instanceof narrowing	`if (e instanceof Error) console.error(e.message)`	Narrows via prototype chain checks.
in-operator narrowing	`if ("id" in obj) obj.id`	Narrows based on property existence.
Truthiness narrowing	`if (s) s.trim()`	Narrows based on falsy/truthy JavaScript semantics.
Equality narrowing	`if (x === null) return`	Narrows unions with `===` / `!==` comparisons.
Discriminated union	`type Shape = { kind: "circle"; r: number } \| { kind: "square"; s: number }`	Uses a shared literal field (`kind`) to narrow via `switch`/`if` checks.
Type predicate	`function isError(x: unknown): x is Error { return x instanceof Error }`	User-defined guard that narrows a value to a specific type.
Inferred type predicate	`const isString = (x: unknown) => typeof x === "string"`	TS 5.5+ automatically infers `x is string` from a boolean-returning function body — no explicit annotation needed.
Assertion function (`asserts`)	`function assertNonNull(x: unknown): asserts x { if (x == null) throw new Error() }`	Narrows by asserting a condition holds when the function returns normally.
Exhaustiveness check	`const _exhaustive: never = value`	Forces the compiler to prove all union cases are handled — errors if a case is missed.

Table 7: Type Operators & Advanced Types

Operator	Example	Description
Type assertion (`as`)	`const input = document.getElementById("id") as HTMLInputElement`	• Overrides TypeScript's inferred type • no runtime effect. Use when you know more than the compiler.
Double assertion	`const x = value as unknown as TargetType`	• Forces conversion between unrelated types via the `unknown` intermediate • use sparingly.
typeof (type context)	`const cfg = { mode: "dev" as const }; type Cfg = typeof cfg`	Extracts a type from a runtime value's shape.
keyof	`type Keys = keyof User`	Produces a union of property keys from an object type.
Indexed access type	`type UserId = User["id"]`	Looks up a property type from another type via `T[K]`.
satisfies	`const routes = { home: "/" } satisfies Record<string, string>`	Checks an expression matches a type without widening the expression's own inferred type.
Mapped type	`type RO<T> = { readonly [K in keyof T]: T[K] }`	Creates a new object type by iterating over keys.
Conditional type	`type IsString<T> = T extends string ? true : false`	Chooses a type based on an `extends` relationship test.
Template literal types	type EventName = `on${Capitalize<string>}`	Builds string types via template literal syntax over string unions.
Key remapping (`as`)	type Getters<T> = { [K in keyof T as `get${Capitalize<string & K>}`]: () => T[K] }	Renames or filters keys while mapping with the `as` clause.
Distributive conditional type	`type ToArray<T> = T extends any ? T[] : never`	Distributes over unions when the checked type is a naked type parameter.
infer	`type Elem<T> = T extends (infer U)[] ? U : T`	Introduces an inferred type variable inside a conditional type.
Variance annotations (`in`/`out`)	`type ReadRef<out T> = { readonly value: T }` `type Writer<in T> = { write(x: T): void }`	• `out` = covariant (used in output position only) • `in` = contravariant (input only); improves checker accuracy (TS 4.7+).
Recursive types	`type JSON = string \| number \| boolean \| null \| JSON[] \| { [k: string]: JSON }`	• A type alias that references itself • supported since TS 3.7 via deferred resolution.

Table 8: Utility Types (Built-in)

Type	Example	Description
Partial<T>	`type Patch = Partial<User>`	Makes all properties of `T` optional.
Required<T>	`type StrictUser = Required<User>`	Makes all properties of `T` required.
Readonly<T>	`type Frozen = Readonly<User>`	Makes all properties of `T` readonly.
Pick<T, K>	`type UserRef = Pick<User, "id" \| "name">`	Selects a subset of properties by key.
Omit<T, K>	`type PublicUser = Omit<User, "email">`	Removes properties by key.
Record<K, T>	`type ById = Record<string, User>`	Maps keys `K` to value type `T`.
Exclude<T, U>	`type NonString = Exclude<string \| number, string>`	Removes from `T` the members assignable to `U`.
Extract<T, U>	`type OnlyString = Extract<string \| number, string>`	Keeps from `T` only the members assignable to `U`.
NonNullable<T>	`type NN = NonNullable<string \| null \| undefined>`	Removes `null` and `undefined` from a type.
ReturnType<T>	`type R = ReturnType<() => Promise<number>>`	Extracts a function type's return type.
Parameters<T>	`type P = Parameters<(x: string, y: number) => void>`	Extracts a function type's parameter tuple.
Awaited<T>	`type V = Awaited<Promise<string>>`	Recursively unwraps the resolved value type of a promise-like.
ConstructorParameters<T>	`class C { constructor(a: string, b: number) {} }` `type P = ConstructorParameters<typeof C> // [string, number]`	Extracts a constructor's parameter types as a tuple.
InstanceType<T>	`type I = InstanceType<typeof User>`	Extracts the instance type of a constructor function type.
NoInfer<T>	`function createStore<T>(init: T, fallback: NoInfer<T>): T { return init ?? fallback }`	Blocks type inference from the wrapped position, forcing `T` to be inferred from other arguments (TS 5.4+).
ThisType<T>	`const mixin: ThisType<{ x: number }> = { getX() { return this.x } }`	Specifies the `this` type for methods in an object literal (requires `noImplicitThis`).
Uppercase<S> / Lowercase<S>	`type U = Uppercase<"hello"> // "HELLO"`	Intrinsic string types that transform string literal types to upper/lower case (TS 4.1+).
Capitalize<S> / Uncapitalize<S>	`type C = Capitalize<"world"> // "World"`	Intrinsic string types that capitalize or uncapitalize the first character of a string literal type (TS 4.1+).
ThisParameterType<T>	`type T = ThisParameterType<(this: Date) => void> // Date`	Extracts the `this` parameter type from a function type.
OmitThisParameter<T>	`type F = OmitThisParameter<(this: Date, x: string) => void>`	Removes the `this` parameter from a function type.

Table 9: Decorators

Decorator	Example	Description
Class decorator	`function sealed(Base: typeof C, ctx: ClassDecoratorContext) {}` `@sealed class C {}`	• Wraps or replaces a class • receives the class and a context object (TS 5.0 Stage 3 syntax).
Method decorator	`function log(fn: Function, ctx: ClassMethodDecoratorContext) { return function(this: any, ...args: any[]) { return fn.apply(this, args) } }` `class C { @log greet() {} }`	• Wraps a method • the replacement function is returned.
Field decorator	`function init<T>(val: T) { return (_: undefined, _ctx: ClassFieldDecoratorContext) => () => val }` `class C { @init("Ada") name!: string }`	• Intercepts field initialization • return an initializer function to override the default value.
Accessor decorator	`function bound(fn: Function, ctx: ClassAccessorDecoratorContext) {}` `class C { @bound accessor name = "Ada" }`	Decorates an `accessor` keyword field, which auto-generates a getter/setter pair.
Getter/setter decorator	`function configurable(fn: Function, ctx: ClassGetterDecoratorContext) {}` `class C { @configurable get x() { return 1 } }`	Decorates a getter or setter individually.
Decorator metadata	`function meta(_: any, ctx: DecoratorContext) { ctx.metadata.info = "x" }` `@meta class C {}; C[Symbol.metadata]`	• TS 5.2+ adds `Symbol.metadata` to classes • decorators can store metadata accessible at runtime.
experimentalDecorators (legacy)	`// tsconfig.json<br> { "compilerOptions": { "experimentalDecorators": true } }`	• Enables the pre-Stage-3 legacy decorator syntax used by Angular, NestJS, and older libraries • incompatible with new Stage 3 decorators.

Table 10: Modules & Imports

Pattern	Example	Description
ES module import/export	`import { readFile } from "node:fs/promises"`	Standard ECMAScript module syntax, fully type-checked by TS.
Type-only import (`import type`)	`import type { User } from "./types"`	Imports a symbol only for the type system — erased entirely at runtime.
Type-only export (`export type`)	`export type { User } from "./types"`	Re-exports types without a runtime export.
Import attributes	`import data from "./data.json" with { type: "json" }`	• Instructs the runtime how to load a module (e.g., JSON) • ECMAScript 2025, supported from TS 5.3.
verbatimModuleSyntax	`// tsconfig.json<br> { "compilerOptions": { "verbatimModuleSyntax": true } }`	Preserves import/export statements literally and enforces `import type` for type-only imports.
ESM/CJS interop	`import pkg from "cjs-only"`	Covers how TS models default/namespace imports across ESM and CommonJS boundaries.
esModuleInterop	`// tsconfig.json<br> { "compilerOptions": { "esModuleInterop": true } }`	Adjusts emit and checking for default/namespace imports to match Node.js/bundler behavior.
allowSyntheticDefaultImports	`// tsconfig.json<br> { "compilerOptions": { "allowSyntheticDefaultImports": true } }`	Allows `default` imports from modules without a default export (type-checking convenience only).
moduleResolution	`// tsconfig.json<br> { "compilerOptions": { "moduleResolution": "bundler" } }`	Selects how imports are resolved: `node16`, `nodenext`, or `bundler` for modern tooling.
module	`// tsconfig.json<br> { "compilerOptions": { "module": "nodenext" } }`	Selects the emitted module format and influences resolution behavior.
baseUrl / paths	`// tsconfig.json<br> { "compilerOptions": { "baseUrl": ".", "paths": { "@/": ["src/"] } } }`	Adds path mapping for module specifiers during type checking and emit.

Table 11: JSX / TSX

Option	Example	Description
TSX file extension	`// Component.tsx<br> export function Button() { return <button /> }`	Enables JSX syntax in TypeScript source files with `.tsx`.
jsx	`// tsconfig.json<br> { "compilerOptions": { "jsx": "react-jsx" } }`	Controls how JSX is transformed or preserved by the compiler.
jsxImportSource	`// tsconfig.json<br> { "compilerOptions": { "jsx": "react-jsx", "jsxImportSource": "preact" } }`	Sets the module for importing `jsx`/`jsxs` factories for the automatic runtime.
JSX.IntrinsicElements	`declare namespace JSX { interface IntrinsicElements { div: any } }`	Declares valid JSX tags and their prop types for type checking.

Table 12: TSConfig Core (Type Checking, Emit, Projects)

Option	Example	Description
strict	`// tsconfig.json<br> { "compilerOptions": { "strict": true } }`	Enables a bundle of strict type-checking flags — the recommended baseline for new projects.
strictNullChecks	`// tsconfig.json<br> { "compilerOptions": { "strictNullChecks": true } }`	Treats `null`/`undefined` as distinct types requiring explicit handling.
noImplicitAny	`// tsconfig.json<br> { "compilerOptions": { "noImplicitAny": true } }`	Errors when the compiler would infer `any` due to missing type information.
target	`// tsconfig.json<br> { "compilerOptions": { "target": "ES2022" } }`	Sets the emitted JS language level and enables corresponding downlevel transforms.
lib	`// tsconfig.json<br> { "compilerOptions": { "lib": ["ES2022", "DOM"] } }`	Selects built-in declaration libraries available (e.g., `DOM`, `ES2022`).
skipLibCheck	`// tsconfig.json<br> { "compilerOptions": { "skipLibCheck": true } }`	• Skips type checking of all `.d.ts` files • improves build speed and avoids third-party type conflicts.
resolveJsonModule	`// tsconfig.json<br> { "compilerOptions": { "resolveJsonModule": true } }`	Allows importing `.json` files with full type inference from their content.
isolatedModules	`// tsconfig.json<br> { "compilerOptions": { "isolatedModules": true } }`	Errors on patterns that require cross-file type information, making single-file transpile tools safe (e.g., esbuild, SWC).
declaration	`// tsconfig.json<br> { "compilerOptions": { "declaration": true } }`	Emits `.d.ts` declaration files describing the public types of each module.
noEmit	`// tsconfig.json<br> { "compilerOptions": { "noEmit": true } }`	Runs type checking only without writing any output files.
incremental	`// tsconfig.json<br> { "compilerOptions": { "incremental": true } }`	Saves build info to a `.tsbuildinfo` file to speed up subsequent compilations.
composite	`// tsconfig.json<br> { "compilerOptions": { "composite": true } }`	Makes a project reference-able in a project references graph and enables build outputs.
references	`// tsconfig.json<br> { "references": [{ "path": "../core" }] }`	Declares dependencies between TS projects for `tsc -b` incremental builds.
exactOptionalPropertyTypes	`// tsconfig.json<br> { "compilerOptions": { "exactOptionalPropertyTypes": true } }`	Makes optional properties more exact: setting `undefined` explicitly is distinct from the property being absent.
useUnknownInCatchVariables	`// tsconfig.json<br> { "compilerOptions": { "useUnknownInCatchVariables": true } }`	Types `catch (e)` as `unknown` instead of `any` for safer error handling.
isolatedDeclarations	`// tsconfig.json<br> { "compilerOptions": { "isolatedDeclarations": true } }`	Requires sufficient type annotations on exports so other tools can generate `.d.ts` files without full type analysis (TS 5.5+).
erasableSyntaxOnly	`// tsconfig.json<br> { "compilerOptions": { "erasableSyntaxOnly": true } }`	Prohibits TS-specific runtime syntax (enums, namespaces, parameter properties) that cannot be stripped by Node.js type-stripping (TS 5.8+).

Table 13: tsc CLI Workflows

Command	Example	Description
Compile current project	`tsc`	Compiles using the nearest `tsconfig.json` in the directory tree.
Type-check only	`tsc --noEmit`	Runs the type checker without producing any JavaScript output.
Watch mode	`tsc --watch`	Recompiles on file changes continuously.
Initialize project	`tsc --init`	Creates a `tsconfig.json` scaffold with annotated options.
Compile by project file	`tsc -p tsconfig.json`	Compiles using an explicit configuration file path.
Build mode (project refs)	`tsc -b`	Builds a referenced project graph in dependency order.
Build with watch	`tsc -b --watch`	Incrementally rebuilds a project reference graph on changes.
Show TypeScript version	`tsc --version`	Prints the installed TypeScript version to stdout.

Table 14: Declaration Files & Augmentation

Pattern	Example	Description
Declaration file (.d.ts)	`// index.d.ts<br> export interface User { id: string }`	Provides type information for JS at compile time with no runtime code.
Global .d.ts	`// globals.d.ts<br> declare const VERSION: string`	Declares globals accessible without imports (ambient global library style).
Module .d.ts	`// index.d.ts<br> declare module "pkg" { export function f(): void }`	Declares the shape of an importable module for untyped JS packages.
declare global	`declare global { interface Window { appVersion: string } }`	Augments global types from within a module (requires at least one `import` or `export`).
Module augmentation	`declare module "express" { interface Request { userId?: string } }`	Adds members to an existing module's declarations without forking the types package.
Declaration merging	`interface Box { size: number }` `interface Box { color: string }`	Multiple declarations with the same name are merged into one combined type.
Triple-slash reference (types)	`/// <reference types="node" />`	• Declares a type package dependency for the file • use `import type` in modules instead.
Triple-slash reference (lib)	`/// <reference lib="dom" />`	Explicitly includes a built-in lib (e.g., `dom`) for the file without changing `tsconfig.json`.

Table 15: Explicit Resource Management

Feature	Example	Description
`using` declaration	`using conn = getConnection()`	Automatically calls `conn[Symbol.dispose]()` when the enclosing scope exits (TS 5.2+, ECMAScript Stage 4).
`await using` declaration	`await using conn = await openConnection()`	Automatically calls `conn[Symbol.asyncDispose]()` when the enclosing async scope exits.
Symbol.dispose	`class Conn { [Symbol.dispose]() { this.close() } }`	• The synchronous cleanup method called by `using` • implement to make a class disposable.
Symbol.asyncDispose	`class Conn { async [Symbol.asyncDispose]() { await this.close() } }`	The asynchronous cleanup method called by `await using`.
Disposable interface	`function use(r: Disposable) { using _ = r; }`	• Interface requiring `[Symbol.dispose]()` • available in `lib: "ES2026"` or `"esnext.disposable"`.
AsyncDisposable interface	`async function use(r: AsyncDisposable) { await using _ = r; }`	Interface requiring `[Symbol.asyncDispose]()`.
DisposableStack	`using stack = new DisposableStack()` `stack.use(resource); stack.defer(() => cleanup())`	• Aggregates multiple resources for disposal in LIFO order • `AsyncDisposableStack` for async variants.

Back to Programming Languages