ES2026 (17th Edition) Is Here: 5 Features You Need to Know

Every June, TC39 ships a new edition of JavaScript, and every year someone asks the same question: “does this language really still need fixing?” Turns out the answer is yes, and the 17th edition, ECMAScript 2026, released this past June, proves it. Nothing here rewrites your codebase overnight, but it does close a handful of small gaps we’ve all learned to quietly work around with extra code.

You can read the full story for free by clicking here

In this article, we’re only covering features that are officially confirmed in the 17th edition, verified directly against the table of contents in the official spec at tc39.es/ecma262/2026. Instead of reading through a dry feature list, let’s compare them directly: how we used to do things, why that approach was painful, and how ES2026 fixes it.

Checking Errors Without Guessing

Ever written a try/catch and then wondered whether what you caught was actually an instance of Error, or just some plain object someone threw? This gets worse when the error comes from a different iframe or a different JavaScript realm, since instanceof Error often fails because every realm has its own Error constructor.

// Old way, can be wrong when the error comes from a different realm
function isError(err) {
  return err instanceof Error; // can return false even for a valid error
}

ES2026 introduces Error.isError(), which checks based on the language specification rather than the prototype chain:

// New way, consistent no matter where the error comes from
function isError(err) {
  return Error.isError(err);
}

It looks small, but if your app deals with multiple modules, web workers, or iframes, this quietly removes one hard-to-trace source of bugs.

Summing Numbers Isn’t as Simple as It Looks

JavaScript uses floating point (IEEE 754) for all numbers, and one side effect is precision loss when you sum a bunch of decimal numbers one by one.

// Old way, precision error accumulates
const numbers = [0.1, 0.2, 0.3];
const total = numbers.reduce((a, b) => a + b, 0);
console.log(total); // 0.6000000000000001, slightly off

With just three numbers, the difference is barely noticeable. But sum up thousands of rows of transaction data, and that tiny drift can turn into a real problem, especially for financial applications. ES2026 adds Math.sumPrecise(), built specifically to sum arrays of numbers with the highest possible precision.

// New way, precise
const total = Math.sumPrecise([0.1, 0.2, 0.3]);
console.log(total); // 0.6, no drift

Simple, but if you work in a field that demands numeric accuracy, this one fixes a genuinely annoying problem.

Checking Map Keys Without Repeating Yourself

If you’ve worked with Map for a while, you've written this pattern more times than you can count: check if a key exists, and if it doesn't, set a default value before moving on.

// Old way, written manually every time
if (!map.has(key)) {
  map.set(key, []);
}
const list = map.get(key);

ES2026 adds Map.prototype.getOrInsert(), which collapses that pattern into one line:

// New way, one line, value returned immediately
const list = map.getOrInsert(key, []);

If the default value is expensive to compute (say, building a heavy object), there’s also getOrInsertComputed(), which takes a function so the value is only computed when it's actually needed:

const set = map.getOrInsertComputed(key, () => new Set());

The same methods apply to WeakMap too, not just regular Map.

Collecting Async Iterables Without the Manual Ritual

Array.from() has long been the go-to for turning an iterable into a regular array. The problem is, it doesn't work with async iterables, like streams, async generators, or data coming from a paginated API.

// Old way, manually looping while awaiting each chunk
async function collectAll(asyncIterable) {
  const result = [];
  for await (const item of asyncIterable) {
    result.push(item);
  }
  return result;
}

ES2026 adds Array.fromAsync(), which handles this directly:

// New way, one call, resolves to an array
const result = await Array.fromAsync(asyncIterable);

If you work with paginated APIs or async generators often, this cuts a fair amount of boilerplate.

Encoding Binary Data Without the Manual Ritual

If you’ve ever worked with binary data, say for file uploads or encryption, you’re probably familiar with the manual dance of converting between Uint8Array and base64 strings.

// Old way, going through btoa/atob and manual conversion
function toBase64(bytes) {
  let binary = "";
  bytes.forEach((b) => (binary += String.fromCharCode(b)));
  return btoa(binary);
}

This approach is prone to bugs when characters fall outside what btoa supports. ES2026 adds native methods directly on Uint8Array:

// New way, one line, no String.fromCharCode trick needed
const bytes = new Uint8Array([72, 101, 108, 108, 111]);
console.log(bytes.toBase64()); // "SGVsbG8="
console.log(bytes.toHex());    // "48656c6c6f"

const decoded = Uint8Array.fromBase64("SGVsbG8=");

Small things like this are what make your code shorter and less error-prone.

What to Take Away

To sum it up, the features officially confirmed in ES2026 aren’t as dramatic as some headlines make them sound, but they still close small gaps we’ve long treated as just part of the job:

• Error checking is now consistent across realms with Error.isError()
• Summing decimal numbers can now be precise with Math.sumPrecise()
• The “check first, then insert” pattern for Map and WeakMap is simplified with getOrInsert() and getOrInsertComputed()
• Collecting data from async iterables into an array now takes one line with Array.fromAsync()
• Converting binary data to base64/hex no longer needs manual tricks, thanks to native Uint8Array methods

Nothing here is dramatic enough to force an urgent migration, but these five features should make your code a little shorter and a little less error-prone. If you want the full details, the official 17th edition spec is always available at tc39.es.

Thousands of developers share what they’re building, learning, and discovering across our publications every month. One account connects you to our entire network of publications and communities. Explore more at plainenglish.io.