Objects

const name = "Ada";
const key = "role";
 
const user = {
  name, // shorthand for name: name
  [key]: "admin", // computed key
  "first-name": "Ada", // quoted key
  greet() {
    return `Hi ${this.name}`;
  },
};
user.greet(); // "Hi Ada"
user.role; // "admin"
 
const proto = { hello: () => "hi" };
const child: typeof proto = Object.create(proto);
child.hello(); // "hi": found on the prototype
 
const prices = new Map([["apple", 1.2], ["pear", 0.8]]);
const obj = Object.fromEntries(prices);
obj; // { apple: 1.2, pear: 0.8 }
const doubled = Object.fromEntries(
  Object.entries(obj).map(([k, v]) => [k, v * 2]),
);
doubled; // { apple: 2.4, pear: 1.6 }
 
const people = [
  { name: "Ada", team: "core" },
  { name: "Lin", team: "web" },
  { name: "Max", team: "core" },
];
const byTeam = Object.groupBy(people, (p) => p.team);
byTeam.core?.length; // 2

type User = {
  name: string;
  address?: { city?: string };
  tags?: string[];
  onSave?: () => void;
};
const u: User = { name: "Ada", address: {} };
 
u.name; // "Ada": dot access
u["name"]; // "Ada": bracket access takes any expression
u.address?.city; // undefined: no error
u.tags?.[0]; // undefined: optional element access
u.onSave?.(); // undefined: the call is skipped
 
const city = u.address?.city ?? "Unknown";
city; // "Unknown"
 
const {
  name,
  address: { city: c = "?" } = {}, // nested, defaults
  ...rest // everything else
} = u;
c; // "?"
rest; // {}

const words = ["the", "constructor", "the"];
const counts: Record<string, number> = {};
for (const w of words) {
  counts[w] = (counts[w] ?? 0) + 1;
}
counts.the; // 2
counts["constructor"];
// "function Object() { [native code] }1"

const tally: Record<string, number> = {};
tally["__proto__"] = (tally["__proto__"] ?? 0) + 1;
Object.keys(tally); // []: the count was lost
 
const safe: Record<string, number> = Object.create(null);
for (const w of ["constructor", "__proto__", "the"]) {
  safe[w] = (safe[w] ?? 0) + 1;
}
Object.keys(safe); // ["constructor", "__proto__", "the"]
 
const plain = {};
"toString" in plain; // true: inherited
Object.hasOwn(plain, "toString"); // false
"toString" in safe; // false

const byId: Record<string, string> = {};
byId[1] = "a"; // stored under "1"
byId["1"]; // "a"
Object.keys(byId); // ["1"]
 
const grid: Record<string, number> = {};
const cell = [1, 2];
// @ts-expect-error: an array can't be an index type
grid[cell] = 5; // stored under "1,2"
grid["1,2"]; // 5

const o = { b: 1, 2: "x", a: 2, 1: "y" };
Object.keys(o); // ["1", "2", "b", "a"]
 
const ids = { 10: "x", 9: "y", "-1": "z", "01": "w" };
Object.keys(ids); // ["9", "10", "-1", "01"]

function firstUnique(s: string): string | undefined {
  const count: Record<string, number> = {};
  for (const ch of s) count[ch] = (count[ch] ?? 0) + 1;
  // wrong: array-index keys come out first
  return Object.keys(count).find((k) => count[k] === 1);
}
firstUnique("ba1"); // "1", though "b" came first
 
function firstUniqueFixed(s: string): string | undefined {
  const count: Record<string, number> = {};
  for (const ch of s) count[ch] = (count[ch] ?? 0) + 1;
  return [...s].find((ch) => count[ch] === 1); // in s order
}
firstUniqueFixed("ba1"); // "b"

const a = { n: 1, tags: ["x"] };
const b = a; // the same object
b.n = 2;
a.n; // 2
a === b; // true
 
const c = { ...a }; // a new object, the same tags array
c.tags.push("y");
a.tags; // ["x", "y"]
a === c; // false
a.tags === c.tags; // true
 
const d = structuredClone(a); // copies all the way down
d.tags.push("z");
a.tags; // ["x", "y"]
d.tags; // ["x", "y", "z"]

const base = { a: 1, nested: { b: 2 } };
const merged = { ...base, a: 9, c: 3 }; // later keys win
merged; // { a: 9, nested: { b: 2 }, c: 3 }
const target = { z: 0 };
Object.assign(target, base); // mutates and returns target
target; // { z: 0, a: 1, nested: { b: 2 } }
 
const verbose = true;
const opts = { ...(verbose && { log: true }) };
opts; // { log: true }: spreading false adds nothing
 
class Pt {
  constructor(public x: number) {}
}
const pc = structuredClone(new Pt(2));
pc instanceof Pt; // false: a plain { x: 2 }

function shallowEqual(
  a: Record<string, unknown>,
  b: Record<string, unknown>,
): boolean {
  const ka = Object.keys(a);
  if (ka.length !== Object.keys(b).length) return false;
  return ka.every(
    (k) => Object.hasOwn(b, k) && Object.is(a[k], b[k]),
  );
}
shallowEqual({ x: 1 }, { x: 1 }); // true
shallowEqual({ x: [1] }, { x: [1] }); // false

const scores = { ada: 3, lin: 5, max: 4 };
 
Object.keys(scores); // ["ada", "lin", "max"]
Object.values(scores); // [3, 5, 4]
Object.entries(scores);
// [["ada", 3], ["lin", 5], ["max", 4]]
 
// sort entries by value, largest first
const ranked = Object.entries(scores)
  .sort(([, x], [, y]) => y - x)
  .map(([who]) => who);
ranked; // ["lin", "max", "ada"]
 
let total = 0;
for (const [, n] of Object.entries(scores)) total += n;
total; // 12

type Pt = { x: number; y: number };
// every Pt from this factory has one shape
const pt = (x: number, y: number): Pt => ({ x, y });
 
const p: Partial<Pt> = {};
p.x = 1;
p.y = 2; // shapes: empty, then x, then x and y
const r: Partial<Pt> = {};
r.y = 1;
r.x = 2; // another branch: y, then y and x
pt(1, 2).x + pt(3, 4).x; // 4

const acct = { id: 1 };
Object.defineProperty(acct, "secret", {
  value: "s3cr3t",
  enumerable: false, // hidden from keys, JSON, spread
});
Object.keys(acct); // ["id"]
const idDesc = Object.getOwnPropertyDescriptor(acct, "id");
idDesc?.writable; // true
const sd = Object.getOwnPropertyDescriptor(acct, "secret");
sd?.writable; // false: defineProperty defaults to false

const DIRS = Object.freeze({
  up: [-1, 0],
  down: [1, 0],
});
// @ts-expect-error: up is readonly
DIRS.up = [0, 0]; // throws TypeError in strict mode
DIRS.up.push(9); // allowed: freeze is shallow
DIRS.up; // [-1, 0, 9]

const temp = {
  celsius: 20,
  get fahrenheit() {
    return (this.celsius * 9) / 5 + 32;
  },
  set fahrenheit(f: number) {
    this.celsius = ((f - 32) * 5) / 9;
  },
};
temp.fahrenheit = 212;
temp.celsius; // 100
 
class Size {
  #px = 0;
  get px(): number {
    return this.#px;
  }
  // a setter may accept a wider type than the getter
  set px(v: number | string) {
    this.#px = Number(v);
  }
  get label() {
    return `${this.#px}px`;
  }
}
const s = new Size();
s.px = "42";
s.px; // 42
// @ts-expect-error: a getter without a setter is readonly
s.label = "x"; // throws TypeError in strict mode

const payload = {
  id: 1,
  at: new Date(0),
  note: undefined,
  big: 10n,
};
const text = JSON.stringify(payload, (_key, value) =>
  typeof value === "bigint" ? value.toString() : value,
);
text;
// '{"id":1,"at":"1970-01-01T00:00:00.000Z","big":"10"}'
 
const back: unknown = JSON.parse(text);
JSON.stringify({ 1: "a" }); // '{"1":"a"}'

import { z } from "zod";
 
const Entry = z.object({
  id: z.number(),
  at: z.coerce.date(),
  tags: z.array(z.string()).default([]),
});
type Entry = z.infer<typeof Entry>;
 
const json = '{"id":1,"at":"2026-01-01"}';
const entry: Entry = Entry.parse(JSON.parse(json));
entry.tags; // []
entry.at instanceof Date; // true

const ab = JSON.stringify({ a: 1, b: 2 });
const ba = JSON.stringify({ b: 2, a: 1 });
ab === ba; // false
 
const stableKey = (o: Record<string, unknown>): string =>
  JSON.stringify(Object.entries(o).sort(([x], [y]) =>
    x < y ? -1 : x > y ? 1 : 0,
  ));
stableKey({ b: 2, a: 1 }); // '[["a",1],["b",2]]'
stableKey({ a: 1, b: 2 }); // '[["a",1],["b",2]]'

type TrieNode = {
  children: Record<string, TrieNode>;
  end: boolean; // a word ends here
};
const newNode = (): TrieNode => ({
  children: {},
  end: false,
});
 
function insert(root: TrieNode, word: string): void {
  let cur = root;
  for (const ch of word) {
    cur = cur.children[ch] ??= newNode();
  }
  cur.end = true;
}
 
function walk(root: TrieNode, s: string) {
  let cur: TrieNode | undefined = root;
  for (const ch of s) cur = cur?.children[ch];
  return cur; // undefined: no word starts with s
}
 
const root = newNode();
for (const w of ["cat", "car", "do"]) insert(root, w);
Object.keys(root.children); // ["c", "d"]
walk(root, "ca")?.end; // false: only a prefix
walk(root, "car")?.end; // true
walk(root, "cow"); // undefined

function twoSum(nums: number[], target: number): number[] {
  const seen: Record<number, number> = {}; // value -> index
  for (const [i, x] of nums.entries()) {
    const j = seen[target - x];
    if (j !== undefined) return [j, i];
    seen[x] = i; // after the check: no self-pairs
  }
  return [];
}
twoSum([3, 2, 4], 6); // [1, 2]
 
const g: Record<string, string[]> = Object.create(null);
for (const [u, v] of [["a", "b"], ["b", "c"]]) {
  (g[u] ??= []).push(v);
  (g[v] ??= []).push(u);
}
g["b"]; // ["a", "c"]

interface Product {
  readonly sku: string; // no reassignment
  name: string;
  price?: number; // optional
  tags: readonly string[]; // a readonly array
}
 
// index signature: any string key
interface HeaderMap {
  [name: string]: string;
  "content-type": string; // known keys must fit it
}
 
// Record: a finite key set, or an open one
type Role = "admin" | "user";
const perms: Record<Role, string[]> = {
  admin: ["*"],
  user: ["read"],
};
const cache: Record<string, number> = {};
perms.user; // ["read"]

const freq: Record<string, number> = { a: 2 };
const n = freq["z"]; // number, but undefined at runtime
n === undefined; // true
const safeN = freq["z"] ?? 0; // 0 with or without the flag
safeN; // 0

const DIRS = {
  up: [-1, 0],
  down: [1, 0],
  left: [0, -1],
  right: [0, 1],
} as const;
type Dir = keyof typeof DIRS; // "up" | "down" | ...
 
function move(r: number, c: number, d: Dir) {
  const [dr, dc] = DIRS[d]; // readonly [-1, 0], ...
  return [r + dr, c + dc] as const;
}
move(2, 2, "left"); // [2, 1]

// a node type can mention itself
type Tree = { val: number; kids: Tree[] };
const t: Tree = { val: 1, kids: [{ val: 2, kids: [] }] };
 
// a tag property lets TypeScript narrow a union
type Shape =
  | { kind: "circle"; r: number }
  | { kind: "rect"; w: number; h: number };
const area = (s: Shape): number =>
  s.kind === "circle" ? Math.PI * s.r ** 2 : s.w * s.h;
area({ kind: "rect", w: 2, h: 3 }); // 6
t.kids.length; // 1

interface Point {
  x: number;
  y: number;
}
 
// @ts-expect-error: 'z' does not exist in type 'Point'
const p1: Point = { x: 1, y: 2, z: 3 };
 
const raw = { x: 1, y: 2, z: 3 };
const p2: Point = raw; // ok: structural, not fresh
p2; // { x: 1, y: 2, z: 3 }: z is still there

type Route = { path: `/${string}`; auth?: boolean };
 
const routes = {
  home: { path: "/" },
  admin: { path: "/admin", auth: true },
} satisfies Record<string, Route>;
 
routes.admin.auth; // true, typed boolean
// @ts-expect-error: no such route
routes.missing;

interface User {
  id: number;
  name: string;
  email?: string;
}
 
type Nullable<T> = { [K in keyof T]: T[K] | null };
 
// modifiers: + adds (the default), - removes
type Mutable<T> = { -readonly [K in keyof T]: T[K] };
type Complete<T> = { [K in keyof T]-?: T[K] };
type Frozen<T> = { +readonly [K in keyof T]: T[K] };
 
type C = Complete<User>; // email: string (required)

type Getters<T> = {
  [K in keyof T as `get${Capitalize<string & K>}`]:
    () => T[K];
};
type UG = Getters<{ id: number; name: string }>;
// getId: () => number; getName: () => string
 
// filter keys: map a key to never to drop it
type PickByValue<T, V> = {
  [K in keyof T as T[K] extends V ? K : never]: T[K];
};
type Strs = PickByValue<{ a: string; b: number }, string>;
// only a: string
 
// keys from a union, not from an object
type Handlers = {
  [E in "click" | "focus" as `on${Capitalize<E>}`]: (
    e: Event,
  ) => void;
};
// onClick and onFocus

interface User2 {
  id: number;
  name: string;
}
 
// make some keys optional
type Optional<T, K extends keyof T> = Omit<T, K> &
  Partial<Pick<T, K>>;
 
// flatten an intersection for nicer hovers
type Prettify<T> = { [K in keyof T]: T[K] } & {};
 
type NewUser = Prettify<Optional<User2, "id">>;
const nu: NewUser = { name: "Ada" }; // id?: number
nu.name; // "Ada"

type DeepReadonly<T> = T extends (
  ...args: never[]
) => unknown
  ? T
  : T extends object
    ? { readonly [K in keyof T]: DeepReadonly<T[K]> }
    : T;
 
type State = DeepReadonly<{
  user: { name: string; tags: string[] };
  count: number;
}>;
const state: State = {
  user: { name: "Ada", tags: ["b", "a"] },
  count: 0,
};
 
// update by copying the path you change
const next: State = {
  ...state,
  user: { ...state.user, tags: [...state.user.tags, "c"] },
  count: state.count + 1,
};
next.user.tags; // ["b", "a", "c"]
state.user.tags; // ["b", "a"]
state.user.tags.toSorted(); // ["a", "b"]: a sorted copy

function wordFreq(text: string): Record<string, number> {
  const count: Record<string, number> = Object.create(null);
  const words = text.toLowerCase().match(/[\w']+/g) ?? [];
  for (const w of words) count[w] = (count[w] ?? 0) + 1;
  return count;
}
const f = wordFreq("The constructor and the __proto__");
f["the"]; // 2
f["constructor"]; // 1
f["__proto__"]; // 1
Object.keys(f).length; // 4

function groupAnagrams(words: string[]): string[][] {
  const groups = Object.groupBy(words, (w) =>
    [...w].sort().join(""),
  );
  return Object.values(groups).filter((g) => !!g);
}
groupAnagrams(["eat", "tea", "tan", "ate", "nat", "bat"]);
// [["eat", "tea", "ate"], ["tan", "nat"], ["bat"]]

type Node = { kids: Record<string, Node>; end: boolean };
 
class Trie {
  #root: Node = { kids: {}, end: false };
 
  insert(word: string): void {
    let cur = this.#root;
    for (const ch of word) {
      cur = cur.kids[ch] ??= { kids: {}, end: false };
    }
    cur.end = true;
  }
  #find(s: string): Node | undefined {
    let cur: Node | undefined = this.#root;
    for (const ch of s) cur = cur?.kids[ch];
    return cur;
  }
  search(word: string): boolean {
    return this.#find(word)?.end ?? false;
  }
  startsWith(prefix: string): boolean {
    return this.#find(prefix) !== undefined;
  }
}
const trie = new Trie();
trie.insert("apple");
trie.search("apple"); // true
trie.search("app"); // false
trie.startsWith("app"); // true

function wordPattern(pattern: string, s: string): boolean {
  const words = s.split(" ");
  if (words.length !== pattern.length) return false;
  const toWord: Record<string, string> = Object.create(null);
  const toChar: Record<string, string> = Object.create(null);
  for (const [i, ch] of [...pattern].entries()) {
    const w = words[i] ?? "";
    if ((toWord[ch] ??= w) !== w) return false;
    if ((toChar[w] ??= ch) !== ch) return false;
  }
  return true;
}
wordPattern("abba", "dog cat cat dog"); // true
wordPattern("abba", "dog dog dog dog"); // false
wordPattern("ab", "constructor toString"); // true

function deepEqual(a: unknown, b: unknown): boolean {
  if (Object.is(a, b)) return true;
  if (typeof a !== "object" || typeof b !== "object") {
    return false;
  }
  if (a === null || b === null) return false;
  if (Array.isArray(a) !== Array.isArray(b)) return false;
  const ka = Object.keys(a);
  const kb = Object.keys(b);
  if (ka.length !== kb.length) return false;
  const ra = a as Record<string, unknown>;
  const rb = b as Record<string, unknown>;
  return ka.every(
    (k) => Object.hasOwn(rb, k) && deepEqual(ra[k], rb[k]),
  );
}
const x = { a: [1, { b: 2 }] };
deepEqual(x, { a: [1, { b: 2 }] }); // true
deepEqual({ a: 1, b: 2 }, { b: 2, a: 1 }); // true
deepEqual([1, 2], { 0: 1, 1: 2 }); // false
deepEqual(NaN, NaN); // true

type Json = string | number | boolean | null | JsonObj;
type JsonObj = { [k: string]: Json };
 
function flatten(
  o: JsonObj,
  pre = "",
): Record<string, Json> {
  const out: Record<string, Json> = {};
  for (const [k, v] of Object.entries(o)) {
    const key = pre ? `${pre}.${k}` : k;
    if (v !== null && typeof v === "object") {
      Object.assign(out, flatten(v, key));
    } else out[key] = v;
  }
  return out;
}
 
function unflatten(flat: Record<string, Json>): JsonObj {
  const root: JsonObj = {};
  for (const [path, v] of Object.entries(flat)) {
    const parts = path.split(".");
    const last = parts.pop() ?? "";
    let cur = root;
    for (const p of parts) {
      const next = cur[p];
      cur = typeof next === "object" && next !== null
        ? next
        : (cur[p] = {});
    }
    cur[last] = v;
  }
  return root;
}
const cfg = { db: { host: "x", port: 5432 }, on: true };
const flat = flatten(cfg);
flat; // { "db.host": "x", "db.port": 5432, on: true }
unflatten(flat);
// { db: { host: "x", port: 5432 }, on: true }

function uniquePaths(rows: number, cols: number): number {
  const memo: Record<string, number> = {};
  const go = (r: number, c: number): number => {
    if (r === rows - 1 || c === cols - 1) return 1;
    const key = `${r},${c}`;
    return (memo[key] ??= go(r + 1, c) + go(r, c + 1));
  };
  return go(0, 0);
}
uniquePaths(3, 7); // 28
uniquePaths(10, 10); // 48620

type Obj = Record<string, unknown>;
const isObj = (v: unknown): v is Obj =>
  typeof v === "object" && v !== null && !Array.isArray(v);
 
function deepMerge(a: Obj, b: Obj): Obj {
  const out: Obj = { ...a };
  for (const [k, v] of Object.entries(b)) {
    const old = out[k];
    out[k] = isObj(old) && isObj(v) ? deepMerge(old, v) : v;
  }
  return out;
}
const base = { db: { host: "x", port: 5432 }, debug: false };
const env = { db: { host: "prod" }, debug: true };
deepMerge(base, env);
// { db: { host: "prod", port: 5432 }, debug: true }