JavaScript: ES2024 Async, Destructuring and Classes Reference Guide

# Node project
npm init -y
echo '{"type":"module"}' > package.json     # opt into ESM

# Run a script
node src/index.js                            # ESM, top-level await OK in 20+
node --watch src/index.js                    # built-in watch mode (Node 18+)

# Or pick a faster runtime
bun  run src/index.js                         # bun: native JS/TS + bundler + test runner
deno run src/index.js                         # deno: secure-by-default, web APIs

# Package manager picks
npm install lodash-es                         # widest compatibility
pnpm add lodash-es                            # fastest in monorepos
bun  add lodash-es                            # fastest single-package

# Format + lint
npx eslint . --fix
npx prettier --write .

// Object destructuring with rename + default
const { name: who = "anon", age } = user;

// Nested + rest
const { profile: { email }, ...rest } = user;

// Array destructuring + skip
const [first, , third, ...tail] = [1, 2, 3, 4, 5];

// Function param destructuring (with defaults)
function greet({ name = "anon", lang = "en" } = {}) {
  return `Hi ${name} (${lang})`;
}

// Spread / rest
const merged   = { ...a, ...b, override: 1 };
const appended = [...arr, 4, 5];

function sum(...nums) {
  return nums.reduce((a, b) => a + b, 0);
}

// Object shorthand + computed keys
const key = "id";
const obj = { name, age, [key]: 42 };

// Optional chaining + nullish coalescing
const city = user?.address?.city ?? "unknown";

// Logical assignment
config.port ??= 3000;      // assign only if nullish
flags.dev  ||= true;       // assign only if falsy
guard.ok   &&= sanitize(); // reassign only if truthy

// Promise basics — sequential
const user = await fetch("/api/users/1").then(r => r.json());

// Parallel: fire requests together, await both
const [u, posts] = await Promise.all([
  fetch("/api/users/1").then(r => r.json()),
  fetch("/api/users/1/posts").then(r => r.json()),
]);

// Race: first to settle wins (incl. rejection)
const fast = await Promise.race([fetchA(), fetchB()]);

// allSettled: collect outcomes, don't short-circuit
const results = await Promise.allSettled(urls.map(u => fetch(u)));
for (const r of results) {
  if (r.status === "fulfilled") console.log(r.value);
  else                          console.warn(r.reason);
}

// Timeout pattern with AbortController
const ctrl = new AbortController();
const t = setTimeout(() => ctrl.abort(), 5_000);
try {
  const res = await fetch(url, { signal: ctrl.signal });
} finally {
  clearTimeout(t);
}

// Async iteration
for await (const chunk of stream) {
  process(chunk);
}

class User {
  // Private fields (real privacy, not convention)
  #id;
  static #count = 0;

  // Public field with default
  active = true;

  constructor(name, email) {
    this.name  = name;
    this.email = email;
    this.#id   = ++User.#count;
  }

  // Getter / setter
  get id()      { return this.#id; }
  set email(v)  { if (!v.includes("@")) throw new Error("bad"); this._email = v; }
  get email()   { return this._email; }

  // Method
  greet() { return `Hi ${this.name}`; }

  // Static
  static fromRow(row) { return new User(row.name, row.email); }

  // Static block (one-time setup at class load)
  static { console.log("User class loaded"); }
}

class Admin extends User {
  constructor(name, email, level) {
    super(name, email);
    this.level = level;
  }
  greet() { return `Admin: ${super.greet()}`; }
}

const u = User.fromRow({ name: "Ada", email: "a@b.c" });
u instanceof User;                  // true
Object.hasOwn(u, "name");          // true

// Tiny rate-limited fetcher: AbortController + retry + concurrency limit.
async function fetchJSON(url, { retries = 2, timeout = 5_000 } = {}) {
  for (let attempt = 0; attempt <= retries; attempt++) {
    const ctrl = new AbortController();
    const t    = setTimeout(() => ctrl.abort(), timeout);
    try {
      const res = await fetch(url, { signal: ctrl.signal });
      if (!res.ok) throw new Error(`${res.status} ${url}`);
      return await res.json();
    } catch (err) {
      if (attempt === retries) throw err;
      await new Promise(r => setTimeout(r, 2 ** attempt * 200));   // backoff
    } finally {
      clearTimeout(t);
    }
  }
}

async function mapLimit(items, limit, fn) {
  const out = new Array(items.length);
  let i = 0;
  await Promise.all(
    Array.from({ length: limit }, async () => {
      while (i < items.length) {
        const idx = i++;
        out[idx] = await fn(items[idx], idx);
      }
    }),
  );
  return out;
}

const urls    = ["/a", "/b", "/c", "/d", "/e"];
const results = await mapLimit(urls, 3, fetchJSON);
console.log(results);