ECMAScript 2026 (ES2026) is finalized, bringing seven new JavaScript features that simplify common patterns. Here's what landed and what's still coming.

1. Map.prototype.getOrInsert() (Upsert)

Until now, adding a value to a Map if the key didn't exist required boilerplate:

const opinions = new Map();
function addOpinion(topic, author) {
  if (!opinions.has(topic)) {
    opinions.set(topic, []);
  }
  opinions.get(topic).push(author);
}

getOrInsert eliminates the check:

opinions.getOrInsert("React is dead", []).push("10x Engineer");

There's also getOrInsertComputed for lazy initialization. Perfect for caching and grouping.

2. Iterator.concat()

Iterator helpers (map, filter) arrived in ES2025. ES2026 adds concat to combine multiple iterators lazily:

function* frontendExperts() {
  yield "React is dead";
  yield "Nobody needs Redux";
}
function* backendExperts() {
  yield "Microservices solve everything";
}
const feed = Iterator.concat(frontendExperts(), backendExperts());

No temporary arrays, no memory bloat.

3. Array.fromAsync()

Async counterpart to Array.from(). Works with async iterators and promises:

async function* angryComments() {
  yield "Angular is dead.";
  yield "JavaScript was a mistake.";
}
const comments = await Array.fromAsync(angryComments());

It also accepts a map function and works with plain promises.

4. Math.sumPrecise()

Fixes floating-point accumulation errors:

console.log(0.1 + 0.2); // 0.30000000000000004
console.log(Math.sumPrecise([0.1, 0.2])); // 0.3

Uses a more accurate algorithm (likely Kahan summation). Essential for financial calculations, stats, or ML.

5. Error.isError()

Cross-realm error detection. instanceof fails across iframes or workers:

const strangeThing = window.frames[0].eval("new Error('fail')");
console.log(strangeThing instanceof Error); // false
console.log(Error.isError(strangeThing)); // true

Library authors rejoice.

6. Base64 for Uint8Array

Native toBase64() and fromBase64() on Uint8Array:

const bytes = new Uint8Array([104, 101, 108, 108, 111]);
console.log(bytes.toBase64()); // "aGVsbG8="

No more btoa(String.fromCharCode(...)) hacks.

7. JSON.parse Source Text Access

The reviver callback now gets a context.source property:

const json = '{"followers":999999999999999999999999999999}';
const data = JSON.parse(json, (key, value, context) => {
  if (key === "followers") return BigInt(context.source);
  return value;
});

Safely handles large numbers without precision loss.

Still Waiting: Temporal API and Pipeline Operator

Temporal (modern date/time API) and the pipeline operator (|>) didn't make ES2026. Both are Stage 3 and already available in some browsers via polyfills, but not yet in the spec.

What You Should Do Now

  • Use Map upsert and Error.isError today in transpiled code.
  • Try Iterator.concat with a polyfill.
  • Keep an eye on Temporal — it's worth learning early.