跪拜 Guibai
← Back to the summary

ES2026 Lands With the Utility Belt JavaScript Should Have Had a Decade Ago

"Perfection is achieved not when there is nothing more to add, but when there is nothing left to take away." — Antoine de Saint-Exupéry

On June 30th, the ECMAScript 2026 specification quietly passed review.

No launch event, no countdown, not even a trending topic. Honestly, that suits the character of this update — heads-down work, no flashy gimmicks.

Scanning the changelog, my first reaction wasn't "wow," but rather —

"How is this only arriving now?"

Map.getOrInsert: Finally, no more writing three lines of boilerplate

Anyone writing JS has experienced this: stuffing data into a Map, appending if the key exists, initializing if it doesn't.

Before ES2026, your code probably looked like this:

const map = new Map();

function addTag(userId, tag) {
  if (!map.has(userId)) {
    map.set(userId, []);
  }
  map.get(userId).push(tag);
}

Three lines to do one thing: check, initialize, append. One lookup for has, another for get, plus the set — congratulations, for a simple "get if there, create if not," you made the engine run three passes.

After ES2026:

const map = new Map();

function addTag(userId, tag) {
  map.getOrInsert(userId, []).push(tag);
}

One line. Done.

And there's also getOrInsertComputed, which only executes the callback to compute the default value when the key doesn't exist. For scenarios with expensive initialization, this saves not just lines of code but real runtime cost.

// Connection pool scenario: create only if absent, reuse if present
const pool = new Map();
const conn = pool.getOrInsertComputed(dbHost, (host) => {
  return createConnection(host); // Executes only the first time
});

Frankly, this API is essentially porting Python's dict.setdefault() and Ruby's Hash#fetch over. Something other languages have had for over a decade, JS only gives you in 2026.

"It's not that JS can't afford it, it's that TC39 moves slowly."

Error.isError: The instanceof pitfall, finally patched

Have you ever encountered this paranormal event: something is clearly an Error, yet instanceof Error tells you "no"?

Don't doubt yourself. This is a classic JS design legacy — cross-realm prototype chain breakage. An Error thrown inside an iframe, an Error passed from a Worker, or even an Error created inside vm.runInNewContext — their Error constructor is simply not the same object as the Error in your current environment.

// Code inside an iframe threw an error
const err = iframeWindow.someFunction(); 

console.log(err instanceof Error); // false
// You stare at the screen: ??? It's clearly an Error ???

The previous workaround usually looked like this:

// "Duck typing" detection, works but you're never confident
function isError(value) {
  return value && typeof value.message === 'string' 
    && typeof value.stack === 'string';
}

It works, but deep down you know it's a hack. Any object with message and stack properties can fool it.

ES2026 delivers a clean, decisive solution:

// Cross-iframe, cross-Worker, cross-Realm, all handled
Error.isError(err); // true, no matter where it came from

No polyfill contortions, no duck-typing insecurity. A native method, standard behavior, settled once and for all.

A similar design precedent already existed — Array.isArray() does exactly the same job. It's just that the Error side took over a decade to catch up, finally paying down some technical debt.

Iterator.zip: Zipper merging, no more hand-rolling indices

Iterating over two arrays simultaneously, matching by index? Previously you probably wrote it like this:

const names = ['Alice', 'Bob', 'Charlie'];
const scores = [92, 87, 95];

// Classic for loop, manual alignment
const results = [];
for (let i = 0; i < Math.min(names.length, scores.length); i++) {
  results.push([names[i], scores[i]]);
}

Hand-rolling indices, Math.min to prevent out-of-bounds — every time you write it, it feels like repetitive labor. A Python programmer seeing this code would probably laugh — a single zip() solves it for them.

ES2026 finally builds this wheel for you:

const names = ['Alice', 'Bob', 'Charlie'];
const scores = [92, 87, 95];

const results = Iterator.zip([names, scores]).toArray();
// [[Alice, 92], [Bob, 87], [Charlie, 95]]

And it provides three modes, even more thoughtful than Python's:

// shortest (default): stops at the shortest iterable
Iterator.zip([a, b]);

// longest: stops at the longest, filling shorter ones with undefined
Iterator.zip([a, b], { mode: 'longest' });

// strict: throws immediately if lengths differ, for scenarios where data must align
Iterator.zip([a, b], { mode: 'strict' });

strict mode is my favorite. If the data doesn't align, it blows up right in your face, preventing those undefined values from silently creeping into your business logic — by the time you notice, two tickets are already open in production.

Math.sumPrecise: The floating-point pitfall, officially patched

Classic interview question: What is 0.1 + 0.2?

console.log(0.1 + 0.2); // 0.30000000000000004

Every JS developer has stepped in this hole, but have you ever considered that when you need to sum a large array, these tiny precision errors snowball with every accumulation?

// Traditional approach: error accumulates with each addition
const total = values.reduce((sum, v) => sum + v, 0);

ES2026's Math.sumPrecise uses a smarter algorithm for floating-point summation — preserving precision as much as possible during computation and rounding only once at the end:

const values = [0.1, 0.2, 0.3, 0.4, 0.5];
Math.sumPrecise(values); // 1.5, clean and crisp

Those doing financial calculations, data statistics, or scientific computing — this method is tailor-made for you. No more hand-rolling Kahan summation algorithms; the standard library has your back.

Some honest thoughts

ES2026 isn't the kind of major release that makes you say "wow." No new syntactic sugar, no revolutionary paradigm shift, no keywords to show off on your resume.

But that's precisely why this feels like the most satisfying update.

Every new API solves a real, concrete pain point for which you've written a workaround ten thousand times.

Map.getOrInsert ends the has-get-set trilogy. Error.isError fills the cross-realm instanceof pitfall. Iterator.zip frees you from hand-rolling index alignment. Math.sumPrecise makes floating-point summation no longer a dark art.

These APIs aren't cool, but they're useful. Like a colleague who quietly fixes bugs — never rushing to speak up at the weekly meeting, but you genuinely wish the team had more people like them.

TC39 did some real work this time.

📊 Data Sources and References

Comments

Top 2 of 4 from juejin.cn, machine-translated. The original thread is authoritative.

动感超人不会飞 6 likes

????

等待丶期待  · 1 likes

Hahaha, I tried it and it's true

动感超人不会飞  → 等待丶期待  · 1 likes

Absolutely ridiculous

大唯

There's a technique called extension methods, which has been around in other languages for a long time. Know about it?