JavaScript

CHALLENGE

class Vehicle {
  #speed = 0;

  constructor(brand) {
    this.brand = brand;
  }

  accelerate(amount) {
    this.#speed += amount;
    return this;
  }

  getSpeed() {
    return this.#speed;
  }

  toString() {
    return `${this.brand} @ ${this.#speed}km/h`;
  }
}

class Car extends Vehicle {
  #gear = 1;

  constructor(brand, model) {
    super(brand);
    this.model = model;
  }

  shiftUp() {
    this.#gear++;
    return this;
  }

  toString() {
    return `${super.toString()} [Gear ${this.#gear}]`;
  }
}

const car = new Car("Toyota", "Supra");
car.accelerate(60).accelerate(40).shiftUp().shiftUp();

console.log(car.toString());
console.log(car instanceof Car);
console.log(car instanceof Vehicle);
console.log(Object.getPrototypeOf(Car) === Vehicle);

CHALLENGE

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(" | "));

🤟 What’s Actually New in JavaScript (And What’s Coming Next) If you don’t read the specs or endless posts about new language features, this is a great way to catch up. Most of the features are supported in Node, like Promise.try, Set union/intersection/difference, Array.fromAsync, and using, with others soon to land, like Math.sumPrecise and Map.getOrInsert (in Node 26). Neciu Dan

CHALLENGE

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();

CHALLENGE

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);

CHALLENGE

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);

👀 Optique 1.0: Type-Safe Combinatorial CLI Parser Build composable parsers for CLIs with type safety, type inference, and built-in shell completion support, plus config file integration and man page generation from the same definitions. v1.0 is the first stable release and Hong compares it to Commander.js and explains why you'd use Optique. Hong Minhee

CHALLENGE

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(", "));

🤔 aube: A New Node.js Package Manager Yes, another one! What’s noteworthy is it comes from the developer of mise, a tool that makes managing numerous languages so much easier. aube’s selling points are raw performance and being a drop-in replacement. Its defaults are also security-focused. Jeff Dickey

CHALLENGE

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();

😃 Git 2.54 has been released with a couple of headline features: • git history offers a new, easy way to edit commit messages or interactively split a commit into two. • You can now define hooks in config files (whether in a repo, at user level, or even system level) rather than just in .git/hooks. You can also run multiple hooks for the same event in this way.

CHALLENGE

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(" | "));