TypeScript Cheat Sheet

Table 1: Type Annotations & Primitive Types

The starting point: how you attach a type to a value, and the built-in primitives you'll annotate with most often. Often you don't write the type at all — inference reads it from the initializer — so the real skill is knowing when an explicit annotation earns its keep. Pay special attention to the three special types at the bottom: any switches checking off, unknown is the safe top type you must narrow first, and never marks code that can't produce a value.

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

Most real-world typing is describing the shape of objects, and these are the tools for it. Interfaces and type aliases both name a shape — interfaces add declaration merging and feel natural for extension, aliases handle any type expression — and on top of either you layer optional and readonly properties, index signatures for open-ended keys, and call or construct signatures for objects that are also callable. The excess-property check is the quirk worth remembering: object literals get scrutinized for stray keys in ways stored variables don't.

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

This is where types start combining into something more expressive than a single shape. Unions say "one of these," intersections say "all of these at once," and literal types pin a value down to an exact string or number — together they're the foundation of modeling states precisely. Tuples, as const, and the two flavors of enum round it out, with the notes flagging which constructs emit runtime code (string and numeric enums) versus which vanish at compile time.

Table 4: Functions (Signatures, Generics, Overloads)

Typing functions covers everything from a plain parameter list to generics that carry types through a call. Generics and their extends constraints are the heart of reusable, type-safe utilities, while overloads let one implementation present several distinct call signatures. The smaller entries — optional, default, and rest parameters, plus newer touches like const type parameters — handle the everyday details of getting arguments and return values typed cleanly.

Table 5: Classes (Members, Modifiers, Inheritance)

TypeScript classes are JavaScript classes with a type layer bolted on: the same fields, methods, and inheritance, plus visibility modifiers, readonly, and implements/abstract for enforcing contracts. Parameter properties are the time-saver — declaring and assigning a field straight from the constructor signature — and the override keyword (with noImplicitOverride) makes inheritance refactors safe. Note that private here is a compile-time guarantee, whereas JS # fields are genuinely private at runtime.

Table 6: Narrowing (Type Guards & Control Flow)

Narrowing is how a broad union type collapses to a specific one inside a branch — the compiler watches your control flow and tracks what a value can still be. The everyday guards reuse plain JavaScript checks (typeof, instanceof, in, truthiness, equality), and discriminated unions make this effortless by tagging each variant with a shared literal field. When the built-in checks aren't enough, type predicates and assertion functions let you teach the compiler your own narrowing logic, and the exhaustiveness pattern catches the case you forgot.

Table 7: Type Operators & Advanced Types

This is type-level programming: operators that compute new types from existing ones rather than just declaring them. keyof, typeof, and indexed access read structure out of other types; mapped types, conditional types, and infer transform and branch on it; template literal types build string types programmatically. It's the most powerful corner of TypeScript and the steepest — but it's what lets a library's types stay perfectly in sync with its data. The satisfies operator is a gentler standout, validating a value against a type without throwing away its narrower inferred shape.

Table 8: Utility Types (Built-in)

These ship with TypeScript and save you from hand-writing the same transformations over and over. Partial, Required, Readonly, Pick, and Omit reshape object types; Record builds dictionaries; Exclude, Extract, and NonNullable filter unions; and ReturnType, Parameters, and Awaited extract pieces out of functions and promises. Knowing this set well means you rarely need to reach for mapped or conditional types directly — they're already wrapped up here.

Table 9: Decorators

Decorators wrap classes and their members to add or alter behavior — the @-prefixed syntax you've seen in frameworks like Angular and NestJS. TypeScript 5.0 adopted the standardized Stage 3 form, where each decorator receives a context object and can replace what it decorates, and 5.2 added a metadata channel via Symbol.metadata. The crucial caveat is that the new Stage 3 decorators are not compatible with the older experimentalDecorators syntax, so libraries pin themselves to one or the other.

Table 10: Modules & Imports

How code is split across files and how TypeScript resolves and emits those boundaries. Standard ESM import/export is fully type-checked, and the type-only variants (import type / export type) signal that a symbol exists purely for the type system and should be erased from the output. The cluster of tsconfig options here — moduleResolution, module, esModuleInterop, paths — is what reconciles TypeScript with the realities of Node.js and bundlers, and is a frequent source of confusing import errors.

Table 11: JSX / TSX

If you write React or any JSX-based UI, these are the knobs that make it type-check. The .tsx extension turns on JSX parsing, the jsx compiler option decides whether that syntax is transformed or preserved, and jsxImportSource points the automatic runtime at the right factory — so you can target Preact or another library instead of React. JSX.IntrinsicElements is where the set of valid built-in tags and their props lives.

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

The compiler options you'll actually set in tsconfig.json, grouped around three jobs: how strictly to check, what to emit, and how to structure multi-package builds. Turning on strict is the single most consequential choice — it bundles a family of safety flags and is the recommended baseline for any new project. The rest control output (target, lib, declaration, noEmit), build speed (incremental, composite, references), and a handful of finer correctness toggles.

Table 13: tsc CLI Workflows

The handful of tsc invocations that cover almost everything you'll do from the command line. tsc --noEmit is the one CI pipelines lean on — type-check without producing any JavaScript — while --watch keeps recompiling as you edit and tsc --init scaffolds a fresh config. The -b build mode is the one to know once a codebase grows into multiple referenced projects, since it rebuilds them in dependency order.

Table 14: Declaration Files & Augmentation

Declaration files (.d.ts) carry types without any runtime code — they're how plain JavaScript packages describe their shapes and how you fill gaps in third-party types. Augmentation is the powerful part: declare global and module augmentation let you add members to existing types (a userId on Express's Request, say) without forking the original package, and declaration merging is the underlying mechanism that makes it work.

Table 15: Explicit Resource Management

A newer TypeScript 5.2 feature that brings deterministic cleanup to JavaScript — think of it as try/finally you don't have to write by hand. Declare a resource with using (or await using for async) and its [Symbol.dispose] method runs automatically when the scope exits, so connections and file handles close even on an early return or thrown error. The Disposable interface defines what makes a class eligible, and DisposableStack groups several resources to tear down together in reverse order.