Objects

const name = "Ada";
const key = "role";
 
const user = {
  name,                        // shorthand for name: name
  [key]: "admin",              // computed key
  "first-name": "Ada",         // quoted key
  greet() {                    // method shorthand
    return `Hi ${this.name}`;
  },
};

const proto = { hello() { return "hi"; } };
const child = Object.create(proto) as typeof proto;
child.hello();
 
const dict: Record<string, number> = Object.create(null);
dict["toString"] = 1;  // no clash with Object.prototype
 
const prices = new Map([["apple", 1.2], ["pear", 0.8]]);
const obj = Object.fromEntries(prices);
// { [k: string]: number }
 
const doubled = Object.fromEntries(
  Object.entries(obj).map(([k, v]) => [k, v * 2]),
);
 
const people = [
  { name: "Ada", team: "core" },
  { name: "Lin", team: "web" },
];
const byTeam = Object.groupBy(people, (p) => p.team);
// Partial<Record<string, { name: string; team: string }[]>>

type User = {
  name: string;
  address?: { city?: string };
  tags?: string[];
  onSave?: () => void;
};
declare const u: User;
 
u.name;               // dot access
u["name"];            // bracket access (any expression)
u.address?.city;      // undefined if address is nullish
u.tags?.[0];          // optional element access
u.onSave?.();         // call only if defined
 
const city = u.address?.city ?? "Unknown";
 
const {
  name,
  address: { city: c = "?" } = {},  // nested + defaults
  ...rest                            // everything else
} = u;

const settings: Record<string, unknown> = { theme: "dark" };
if (Object.hasOwn(settings, "theme")) {
  console.log(settings.theme);
}

const base = { a: 1, nested: { b: 2 } };
 
const copy = { ...base };               // shallow
const merged = { ...base, a: 9, c: 3 }; // later keys win
const assigned = Object.assign({}, base, { c: 3 });
 
copy.nested.b = 99;       // also changes base.nested.b!
 
const deep = structuredClone(base);
deep.nested.b = 1;        // base untouched
 
// Conditional spread
const flag = true;
const opts = { ...(flag && { verbose: true }) };

const scores = { ada: 3, lin: 5 };
 
Object.keys(scores);     // string[]  ["ada", "lin"]
Object.values(scores);   // number[]  [3, 5]
Object.entries(scores);  // [string, number][]
 
for (const [who, n] of Object.entries(scores)) {
  console.log(who, n.toFixed(1));
}
 
// Typed keys: only safe if no extra keys exist at runtime
const keys = Object.keys(scores) as (keyof typeof scores)[];

const o = { b: 1, 2: "x", a: 2, 1: "y" };
Object.keys(o);  // ["1", "2", "b", "a"]

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

const cfg = Object.freeze({ port: 80, db: { host: "x" } });
// @ts-expect-error readonly property
cfg.port = 81;
cfg.db.host = "y";  // allowed: freeze is shallow

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]),
  );
}

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; }
  // setter may accept a wider type (TS 5.1+)
  set px(v: number | string) { this.#px = Number(v); }
  get label() { return `${this.#px}px`; }  // getter only
}
const s = new Size();
s.px = "42";             // s.px is number
// @ts-expect-error getter-only is readonly
s.label = "x";

const visits = new Map<string, number>();
visits.set("/", (visits.get("/") ?? 0) + 1);
for (const [path, n] of visits) console.log(path, n);
 
const meta = new WeakMap<object, { seen: number }>();
const el = {};
meta.set(el, { seen: Date.now() });  // gone when el is GC'd

const frontend = new Set(["ts", "css", "html"]);
const backend = new Set(["ts", "sql"]);
 
frontend.union(backend);        // ts, css, html, sql
frontend.intersection(backend); // ts
frontend.difference(backend);   // css, html
frontend.isDisjointFrom(new Set(["go"]));  // true
 
const unique = [...new Set([1, 1, 2])];     // [1, 2]

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,
  2, // indent
);
// "note" is gone, "at" is "1970-01-01T00:00:00.000Z"
 
const ISO = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}/;
const back = JSON.parse(text, (_key, value) =>
  typeof value === "string" && ISO.test(value)
    ? new Date(value)
    : value,
) as unknown;

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.at is a Date, entry.tags is []

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

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

type Route = { path: `/${string}`; auth?: boolean };
 
const routes = {
  home: { path: "/" },
  admin: { path: "/admin", auth: true },
} satisfies Record<string, Route>;
 
routes.admin.auth;    // boolean, key known
// @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 (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 to never to drop them
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>;
// { a: string }
 
// Keys from a union, not from an object
type Handlers = {
  [E in "click" | "focus" as `on${Capitalize<E>}`]:
    (e: Event) => void;
};
// { onClick: ...; onFocus: ... }

// 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">>;
// { name: string; id?: number }
interface User2 { id: number; name: string }

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;
}>;
 
declare const state: State;
// @ts-expect-error readonly deep down
state.user.tags.push("x");
 
// Update by copying the path you change
const next: State = {
  ...state,
  user: { ...state.user, tags: [...state.user.tags, "x"] },
  count: state.count + 1,
};
 
// ES2023 non-mutating array methods
const sorted = state.user.tags.toSorted();
const swapped = state.user.tags.with(0, "first");