Advanced JavaScript

const res = {
  status: 200,
  data: { user: { id: 7, name: "Ada", roles: ["admin", "dev"] }, meta: { page: 1 } },
}

// Nested, renamed, defaulted — all at once
const { status, data: { user: { name, roles: [primaryRole, ...otherRoles] }, meta: { page, size = 20 } } } = res
console.log(status, name, primaryRole, otherRoles, page, size)

// In function parameters and loops
const users = [{ id: 1, name: "Ada", tags: ["x"] }, { id: 2, name: "Bob", tags: [] }]
for (const { id, name, tags: [firstTag = "none"] } of users) console.log(id, name, firstTag)
const names = users.map(({ name }) => name)
console.log(names)

// Swap, skip, rest
let a = 1, b = 2
;[a, b] = [b, a]
const [, second, ...tail] = [10, 20, 30, 40]
console.log(a, b, second, tail)

// Spread: copy + override (immutable update pattern), merge, convert
const updated = { ...res.data.user, name: "Grace", roles: [...res.data.user.roles, "ops"] }
console.log(updated, res.data.user.name)          // original untouched
console.log({ ...{ a: 1, b: 1 }, ...{ b: 2, c: 3 } })  // later wins
console.log([...new Set([3, 1, 3])], [..."hey"], Math.max(...[4, 9, 2]))

// Rest in objects: "everything except"
const { id, ...withoutId } = res.data.user
console.log(id, withoutId)

// Destructuring from a function that returns several things
const minMax = arr => [Math.min(...arr), Math.max(...arr)]
const [lo, hi] = minMax([5, 2, 9])
console.log(lo, hi)

// The protocol by hand
const countdown = {
  from: 3,
  [Symbol.iterator]() {
    let n = this.from
    return { next: () => (n > 0 ? { value: n--, done: false } : { value: undefined, done: true }) }
  },
}
console.log([...countdown])

// The same with a generator
function* countdownGen(from) {
  while (from > 0) yield from--
}
console.log([...countdownGen(3)])

// Step by step: yield pauses
function* steps() {
  console.log("  start")
  yield 1
  console.log("  between")
  yield 2
  console.log("  end")
  return "done"
}
const it = steps()
console.log("created, nothing ran yet")
console.log(it.next())
console.log(it.next())
console.log(it.next())
console.log(it.next())

// Infinite sequences are fine — take what you need
function* naturals() { let n = 1; while (true) yield n++ }
function* take(iter, k) { for (const v of iter) { if (k-- <= 0) return; yield v } }
function* map(iter, fn) { for (const v of iter) yield fn(v) }
console.log([...take(map(naturals(), n => n * n), 5)])

// Generators can receive values too
function* accumulator() {
  let total = 0
  while (true) total += yield total
}
const acc = accumulator()
acc.next()                       // prime it
console.log(acc.next(10).value, acc.next(5).value)

// Iterator helpers (ES2025) — on real engines
console.log(typeof Iterator !== "undefined" && Iterator.prototype.map ? "iterator helpers available" : "use the generator versions above")

const state = { user: { name: "Ada", prefs: { theme: "light" } }, items: [1, 2] }

// Immutable update: new objects along the path that changed, shared elsewhere
const next = { ...state, user: { ...state.user, prefs: { ...state.user.prefs, theme: "dark" } } }
console.log(next.user.prefs.theme, state.user.prefs.theme)      // old is untouched
console.log(next.items === state.items, next.user === state.user)  // unchanged parts are SHARED

// Arrays: prefer the non-mutating forms
const items = [3, 1, 2]
const sorted = items.toSorted(), added = [...items, 4], removed = items.filter(x => x !== 1), replaced = items.with(0, 9)
console.log(items, sorted, added, removed, replaced)

// Shallow copy shares nested objects — the classic trap
const shallow = { ...state }
shallow.user.name = "Bob"
console.log(state.user.name)      // changed! shallow.user IS state.user

// Deep copy
const deep = structuredClone(state)
deep.user.name = "Cy"
console.log(state.user.name, deep.user.name)

// Freeze (shallow) — writes are ignored in sloppy mode, throw in strict
const config = Object.freeze({ port: 3000, nested: { ok: true } })
try { "use strict"; config.port = 1 } catch (e) { console.log(e.name) }
config.nested.ok = false           // nested objects are NOT frozen
console.log(config.port, config.nested.ok, Object.isFrozen(config))

// Deep freeze for real immutability in dev
function deepFreeze(o) { for (const v of Object.values(o)) if (v && typeof v === "object") deepFreeze(v); return Object.freeze(o) }
const frozen = deepFreeze({ a: { b: 1 } })
console.log(Object.isFrozen(frozen.a))

// test: does it match?
console.log(/^\d{4}-\d{2}-\d{2}$/.test("2026-09-20"), /^\d{4}-\d{2}-\d{2}$/.test("20-09-2026"))
const email = /^[^\s@]+@[^\s@]+\.[^\s@]+$/
console.log(email.test("[email protected]"), email.test("not an email"))

// match with named groups: extract parts
const m = "2026-09-20".match(/(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})/)
console.log(m.groups.year, m.groups.month, m[0], m.index)

// g flag: all matches
console.log("a1b22c333".match(/\d+/g))
for (const { groups } of "x=1, y=22".matchAll(/(?<k>\w+)=(?<v>\d+)/g)) console.log(groups.k, "→", Number(groups.v))

// replace with a pattern, a group reference, or a function
console.log("2026-09-20".replace(/(\d+)-(\d+)-(\d+)/, "$3/$2/$1"))
console.log("hello world".replace(/\b\w/g, c => c.toUpperCase()))
console.log("  too   many   spaces ".trim().replace(/\s+/g, " "))
console.log("price: $42.50".replace(/[^\d.]/g, ""))

// split on a pattern
console.log("a, b;c  d".split(/[,;\s]+/))

// Flags: i (ignore case), m (multiline ^$), s (dot matches newline), u (unicode)
console.log(/hello/i.test("HELLO"), "line1\nline2".match(/^line\d$/gm))

// Escaping user input before putting it in a pattern
const escapeRe = s => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")
console.log(new RegExp(escapeRe("a.b")).test("a.b"), new RegExp(escapeRe("a.b")).test("axb"))

// Slugify: the regex you will write most
const slugify = s => s.toLowerCase().trim().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "")
console.log(slugify("  Hello, World! 2026 "))

// Creating
const epoch = new Date(0)
const fromIso = new Date("2026-09-20T10:30:00Z")           // Z = UTC. Always include the zone.
const fromParts = new Date(Date.UTC(2026, 8, 20, 10, 30))  // month 8 = September!
console.log(epoch.toISOString(), fromIso.getTime() === fromParts.getTime())

// Reading (UTC getters — the local ones depend on the machine)
console.log(fromIso.getUTCFullYear(), fromIso.getUTCMonth() + 1, fromIso.getUTCDate(), fromIso.getUTCDay())   // day 0 = Sunday

// Arithmetic: work in milliseconds
const DAY = 24 * 60 * 60 * 1000
const nextWeek = new Date(fromIso.getTime() + 7 * DAY)
console.log(nextWeek.toISOString().slice(0, 10), Math.round((nextWeek - fromIso) / DAY), "days")

// Rollover: convenient and dangerous
const d = new Date(Date.UTC(2026, 0, 31))
d.setUTCMonth(1)                    // Feb 31 → rolls to March 3
console.log(d.toISOString().slice(0, 10))

// Invalid dates do not throw
const bad = new Date("not a date")
console.log(Number.isNaN(bad.getTime()), String(bad))

// Formatting for humans — Intl, with an explicit time zone
const fmt = new Intl.DateTimeFormat("en-GB", { dateStyle: "long", timeStyle: "short", timeZone: "Asia/Kolkata" })
console.log(fmt.format(fromIso))
console.log(new Intl.RelativeTimeFormat("en", { numeric: "auto" }).format(-1, "day"))

// Durations and timestamps
console.log(typeof Date.now(), Date.now() > 1.7e12)
const t0 = Date.now(); for (let i = 0; i < 1e4; i++); console.log("elapsed ms is a number:", typeof (Date.now() - t0))

// memoize with any number of args (key by JSON)
function memoize(fn) {
  const cache = new Map()
  return (...args) => {
    const key = JSON.stringify(args)
    if (!cache.has(key)) cache.set(key, fn(...args))
    return cache.get(key)
  }
}
let computed = 0
const slowAdd = memoize((a, b) => { computed++; return a + b })
console.log(slowAdd(1, 2), slowAdd(1, 2), slowAdd(2, 3), "computed:", computed)

// curry: turn f(a, b, c) into f(a)(b)(c) — or f(a, b)(c)
const curry = fn => function curried(...args) {
  return args.length >= fn.length ? fn(...args) : (...more) => curried(...args, ...more)
}
const volume = curry((l, w, h) => l * w * h)
console.log(volume(2)(3)(4), volume(2, 3)(4), volume(2, 3, 4))

// partial application: fix the first arguments
const partial = (fn, ...fixed) => (...rest) => fn(...fixed, ...rest)
const greet = (greeting, name) => `${greeting}, ${name}`
const hello = partial(greet, "Hello")
console.log(hello("Ada"), hello("Bob"))

// compose / pipe
const pipe = (...fns) => x => fns.reduce((v, f) => f(v), x)
const cleanEmail = pipe(s => s.trim(), s => s.toLowerCase())
console.log(cleanEmail("  [email protected] "))

// A module-style singleton with private state
const logger = (() => {
  const lines = []
  return {
    log: msg => { lines.push(msg); return lines.length },
    dump: () => [...lines],
  }
})()
logger.log("a"); logger.log("b")
console.log(logger.dump(), logger.lines)

// throttle: at most once per window
function throttle(fn, ms) {
  let last = -Infinity
  return (...args) => {
    const now = Date.now()
    if (now - last >= ms) { last = now; return fn(...args) }
  }
}
const t = throttle(x => `ran ${x}`, 1000)
console.log(t(1), t(2), t(3))      // only the first runs inside the window

// Symbol: unique, hidden keys
const ID = Symbol("id")
const user = { name: "Ada", [ID]: 42 }
console.log(user[ID], Object.keys(user), JSON.stringify(user), ID.toString(), Symbol("id") === ID)

// Well-known symbols: customise how the language treats your object
const money = {
  cents: 1999,
  [Symbol.toPrimitive](hint) { return hint === "string" ? `$${(this.cents / 100).toFixed(2)}` : this.cents / 100 },
}
console.log(String(money), money * 2, money + 1)

// WeakMap: private data per object, garbage-collected with the object
const meta = new WeakMap()
function tag(obj, info) { meta.set(obj, info); return obj }
const el = tag({ kind: "button" }, { clicks: 0 })
meta.get(el).clicks++
console.log(meta.get(el), meta.has({}))

// Proxy: validation on write, defaults on read, logging
const validated = new Proxy({}, {
  set(target, key, value) {
    if (key === "age" && !Number.isInteger(value)) throw new TypeError("age must be an integer")
    target[key] = value
    return true
  },
  get(target, key) { return key in target ? target[key] : `<no ${String(key)}>` },
})
validated.age = 36
console.log(validated.age, validated.missing)
try { validated.age = "old" } catch (e) { console.log(e.message) }

// Reflect mirrors the operations a Proxy can intercept
console.log(Reflect.has(user, "name"), Reflect.ownKeys(user).length)