JavaScript

const EventEmitter = (() => {
  const listeners = new WeakMap();

  return class {
    constructor() {
      listeners.set(this, {});
    }

    on(event, fn) {
      const map = listeners.get(this);
      (map[event] ??= []).push(fn);
      return this;
    }

    emit(event, ...args) {
      const map = listeners.get(this);
      (map[event] ?? []).forEach(fn => fn(...args));
      return this;
    }
  };
})();

const bus = new EventEmitter();
const log = [];

bus
  .on("data", val => log.push(`A:${val}`))
  .on("data", val => log.push(`B:${val}`))
  .on("done", ()  => log.push("done"));

bus.emit("data", 1).emit("data", 2).emit("done");

console.log(log.join(" | "));

async function fetchData(id) {
  if (id < 0) throw new Error("Invalid ID");
  return { id, value: id * 10 };
}

async function process() {
  const results = await Promise.allSettled([
    fetchData(1),
    fetchData(-1),
    fetchData(3),
  ]);

  results.forEach(({ status, value, reason }) => {
    if (status === "fulfilled") {
      console.log(`fulfilled: ${value.id} -> ${value.value}`);
    } else {
      console.log(`rejected: ${reason.message}`);
    }
  });
}

process();

const config = {
  host: "localhost",
  port: 3000,
  db: {
    name: "mydb",
    maxConnections: 10
  }
};

Object.freeze(config);

config.port = 9999;
config.db.maxConnections = 99;
config.newProp = "surprise";
delete config.host;

const sealed = Object.seal({ x: 1, y: 2 });
sealed.x = 100;
sealed.z = 999;
delete sealed.y;

console.log(config.port, config.db.maxConnections, config.host);
console.log(sealed.x, sealed.y, sealed.z);

function* counter(start, end) {
  for (let i = start; i <= end; i++) {
    yield i;
  }
}

function* pipeline() {
  const first = yield* counter(1, 3);
  console.log("Counter done:", first);

  yield "bridge";

  const second = yield* counter(7, 9);
  console.log("Counter done:", second);
}

const gen = pipeline();

const results = [];
let next = gen.next();
while (!next.done) {
  results.push(next.value);
  next = gen.next();
}

console.log(results);

class ValidationError extends Error {
  constructor(message, field) {
    super(message);
    this.name = "ValidationError";
    this.field = field;
  }
}

class NetworkError extends ValidationError {
  constructor(message, field, statusCode) {
    super(message, field);
    this.name = "NetworkError";
    this.statusCode = statusCode;
  }
}

const err = new NetworkError("Not Found", "endpoint", 404);

console.log([
  err instanceof NetworkError,
  err instanceof ValidationError,
  err instanceof Error,
  err instanceof TypeError,
].join(", "));

async function* paginate(items, pageSize) {
  for (let i = 0; i < items.length; i += pageSize) {
    const page = items.slice(i, i + pageSize);
    yield await Promise.resolve(page);
  }
}

async function* transform(source, fn) {
  for await (const chunk of source) {
    yield fn(chunk);
  }
}

async function run() {
  const data = [10, 20, 30, 40, 50, 60];

  const pages = paginate(data, 2);
  const mapped = transform(pages, (page) => page.map((x) => x * 2));

  const results = [];
  for await (const page of mapped) {
    results.push(page.reduce((a, b) => a + b, 0));
  }

  console.log(results);
}

run();

const values = [0.1 + 0.2, NaN, Infinity, -0, 42.6789];

const results = values.map((v, i) => {
  if (i === 0) return v.toFixed(2);
  if (i === 1) return Number.isFinite(v) + " " + Number.isNaN(v);
  if (i === 2) return Number.isFinite(v) + " " + isFinite(v);
  if (i === 3) return Object.is(v, 0) + " " + Object.is(v, -0);
  if (i === 4) return v.toPrecision(4);
});

console.log(results.join(" | "));