JavaScript & TypeScript Cheat Sheet

Variables, Types & Operators #

Strings & Numbers #

Arrays #

Objects #

Control Flow & Functions #

Classes & Modules #

class Animal {
  static count = 0;           // static field (ES2022)
  #secret = "hidden";         // truly private field (ES2022)
  sound = "...";              // public field
  constructor(name) { this.name = name; Animal.count++; }
  speak() { return `${this.name} says ${this.sound}`; }
  get secretLength() { return this.#secret.length; }
}
class Dog extends Animal {
  sound = "woof";
  speak() { return super.speak() + "!"; }
}
new Dog("Rex").speak();       // "Rex says woof!"

Promises, Async & Errors #

async function getUser(id) {
  const res = await fetch(`/api/users/${id}`);
  if (!res.ok) throw new Error(`HTTP ${res.status}`); // 404/500 don't reject!
  return res.json();
}
try {
  const user = await getUser(1);
} catch (err) {
  console.error("Failed:", err.message);
} finally {
  spinner.hidden = true;      // runs either way
}

Map, Set, JSON & Dates #

DOM Basics #

TypeScript Basics #

interface User {               // object shapes; can extend and be merged
  readonly id: number;
  name: string;
  email?: string;
}
interface Admin extends User { role: "admin" }
type ID = string | number;     // type alias: also unions, tuples, primitives
type Point3D = { x: number; y: number } & { z: number };

Generics & Utility Types #

function first<T>(items: T[]): T | undefined { return items[0]; }
first([1, 2]);                 // T is inferred as number
interface ApiResponse<T> { data: T; error?: string }
function longest<T extends { length: number }>(a: T, b: T): T {
  return a.length >= b.length ? a : b;
}

Narrowing & Type Tricks #

type Shape = { kind: "circle"; radius: number } | { kind: "rect"; w: number; h: number };
function area(s: Shape): number {
  switch (s.kind) {            // discriminated union: TS narrows per case
    case "circle": return Math.PI * s.radius ** 2;
    case "rect": return s.w * s.h;
    default: { const missing: never = s; return missing; } // error if a case is missing
  }
}
const ROLES = ["admin", "editor"] as const;
type Role = (typeof ROLES)[number];            // "admin" | "editor"
const config = { port: 3000 } satisfies Record<string, string | number>;
config.port.toFixed();                         // still number, not string | number

TypeScript Setup & Running #

Tips #

• Default to const and ===; reach for let only when you reassign.
• [10, 9, 1].sort() gives [1, 10, 9] because it compares strings: pass (a, b) => a - b for numbers.
• forEach doesn't wait for await: use for...of to go one by one, or await Promise.all(items.map(fn)) for parallel.
• fetch only rejects on network errors: always check res.ok before reading the body.
• Types vanish at runtime: validate API responses and JSON.parse results (for example with Zod) instead of trusting as.
• Prefer unknown over any. Since TS 6, tsc file.ts stops with an error when a tsconfig.json is present: run plain npx tsc (or add --ignoreConfig).