Every June, TC39 ships a new ECMAScript edition, and most years it's a handful of syntax conveniences nobody gets too excited about. ES2026 is different. Several proposals that have been sitting in committee for the better part of a decade most notably Temporal, the long-promised replacement for Date finally hit Stage 4 and shipped.
Here are 10 features from ES2026 that are actually worth rewiring your habits for.
1. Temporal- Date is finally dead
Date was modeled on java.util.Date back in 1995. Java deprecated it in 1997. We kept using it for almost 30 years anyway mutable, zero-indexed months, no real time zone support, and arithmetic that made everyone reach for date-fns, Luxon, Moment, or Day.js.
Temporal fixes all of it: immutable objects, explicit distinction between "wall-clock time" and "absolute instant," and real calendar/time-zone awareness.
const now = Temporal.Now.plainDateTimeISO();
const future = now.add({ days: 30 });
const diff = future.since(now); // { days: 30 }
// Time zones done right
const meeting = Temporal.ZonedDateTime.from({
year: 2026, month: 6, day: 15, hour: 14,
timeZone: 'America/New_York'
});
const inTokyo = meeting.withTimeZone('Asia/Tokyo');
For a lot of projects, this single feature quietly removes the need for a date library entirely.
2. Array "by copy" methods
React reducers, Redux, and anything built around immutable state updates have long relied on spreading arrays just to avoid mutating them. ES2026 solidifies the non-mutating counterparts to the classic mutating array methods:
const sorted = arr.toSorted((a, b) => a - b);
const reversed = arr.toReversed();
const spliced = arr.toSpliced(1, 2, 'new');
const updated = arr.with(0, 'replaced');
No shallow copies, no utility libraries the array you started with is untouched.
3. Set composition methods
Set finally grows the operations you'd expect from any collections library:
const a = new Set([1, 2, 3]);
const b = new Set([2, 3, 4]);
a.union(b); // {1,2,3,4}
a.intersection(b); // {2,3}
a.difference(b); // {1}
a.symmetricDifference(b); // {1,4}
a.isSubsetOf(b);
a.isSupersetOf(b);
a.isDisjointFrom(b);
Simple set logic that previously meant converting to arrays and filtering by hand.
4. Iterator helpers
Iterating lazily over generators or custom iterables used to mean manual for...of loops or eagerly materializing arrays. Iterator helpers add functional-style methods directly to the iterator protocol and they're lazy by default:
const result = Iterator.from(hugeArray)
.map(x => x * 2)
.filter(x => x > 10)
.take(3)
.toArray();
// stops computing after the third match no intermediate arrays
Compare that to a chained .map().filter().slice() on an array, which builds a full intermediate array at every step.
5. Map.prototype.getOrInsert
The "check if a key exists, otherwise set a default" pattern shows up constantly:
// before
if (!map.has(key)) {
map.set(key, defaultValue);
}
const value = map.get(key);
// ES2026
const value = map.getOrInsert(key, defaultValue);
One call, one lookup, no repetition. WeakMap gets the same treatment.
6. using / await using explicit resource management
Two new keywords bring deterministic, scope-based cleanup to JavaScript, similar to try-with-resources in other languages:
class DbConnection {
constructor(name) { this.name = name; }
[Symbol.dispose]() { console.log(`Closing ${this.name}`); }
}
function run() {
using conn = new DbConnection('primary');
// conn is automatically disposed at the end of this block
}
await using does the same thing for resources that need asynchronous teardown (streams, connections that close over the network, etc.), cutting down on nested try...finally blocks.
7. RegExp.escape()
Building a regex dynamically from user input has always meant reaching for a hand-rolled escape function or the escape-string-regexp npm package. It's now a built-in:
const userInput = "Is this a (regex) test?";
const safe = new RegExp(RegExp.escape(userInput));
Small feature, but it removes a whole category of "oops, unescaped special character broke the regex" bugs.
8. Promise.try()
A subtle but genuinely annoying inconsistency: calling a function that might throw synchronously or return a rejected promise required different error-handling paths. Promise.try() normalizes both into a single promise chain:
Promise.try(() => mightThrowOrReturnPromise())
.then(result => console.log(result))
.catch(err => console.error(err));
No more wrapping sync calls in Promise.resolve().then(...) just to get uniform error handling.
9. Uint8Array Base64 and hex conversion
Converting binary data to and from Base64 or hex has always meant either atob/btoa gymnastics (which don't handle bytes correctly) or a small library. Now it's native:
const bytes = new Uint8Array([72, 101, 108, 108, 111]);
const base64 = bytes.toBase64(); // "SGVsbG8="
const restored = Uint8Array.fromBase64(base64);
const hex = bytes.toHex(); // "48656c6c6f"
const fromHex = Uint8Array.fromHex(hex);
Handy for anything dealing with binary payloads, crypto, or file encoding without pulling in a dependency.
10. Math.sumPrecise() and Error.isError()
Two smaller but genuinely useful additions:
-
Math.sumPrecise(iterable)sums a list of numbers without accumulating floating-point error the way a naive loop does worth knowing about for anything financial or scientific. -
Error.isError(value)reliably checks whether a value is anErrorinstance, even across realms/iframes, whereinstanceof Errorcan silently fail.
Math.sumPrecise([0.1, 0.2, 0.3]); // no floating-point drift
Error.isError(new TypeError('x')); // true
Error.isError({ message: 'fake' }); // false
Should you use these today?
Engine support is still catching up as of mid-2026 check caniuse.com or node.green before shipping any of this to production without a fallback. Temporal in particular is brand new to the spec after years in Stage 3, so browser support (Safari especially) is the long pole. But for Node.js backends and evergreen-browser frontends, most of this list is either already usable or one polyfill away.
The bigger takeaway: ES2026 isn't a "nice-to-have syntax sugar" release. Between Temporal, iterator helpers, and explicit resource management, it's chipping away at problems JavaScript developers have been quietly working around for two decades.
📚 Want the deeper dive? Read the full breakdown here: JavaScript ES2026: New Features Every Developer Must Know
What are you most excited to actually use? Drop a comment below.
Top comments (2)
'Upsert' (update or insert) is really not the same thing as 'getOrInsert'
Totally fair "upsert" technically implies update-or-insert, and getOrInsert is really just insert-if-missing, so it doesn't touch existing values at all. I was drawing a loose parallel to the "avoid a separate has-check" pattern, but you're right that the semantics aren't the same. Appreciate you pointing it out, will tighten that wording up in the article so it doesn't mislead anyone else. 🙌