JavaScript in 2026: the ECMAScript 2025 features worth learning now

A status report on the language

An overview post titled "What to Know in JavaScript (2026 Edition)," published on blog.master.dev and pushed to Hacker News's front page in late September 2026, takes stock of what JavaScript practitioners should have on their radar. The author frames the language as one that versions itself on a predictable yearly schedule, while acknowledging that working in JavaScript extends well past the core language into runtimes, frameworks, libraries and tooling. The circulated text concentrates on the language layer, walking through the headline features of ECMAScript 2025, which was finalized in June 2025, and closing with a note that the list is not exhaustive.

Iterator helpers bring lazy evaluation to chains

According to the post, ECMAScript 2025 adds methods such as .map(), .filter(), .take() and .drop() directly to iterators, evaluated lazily. The author, describing himself as largely a front-end developer, admits the feature can look esoteric at first — arrays already have these methods — but points to the performance angle: chaining array methods allocates a new array at every step, which gets expensive on large collections. With the new helpers, a chain built through Iterator.from() performs no intermediate allocations and stops computing once enough results have been produced, for example after take(3). A further benefit is that Iterator.from() accepts anything iterable, so sets, maps and generators all gain the same toolkit.

Sets finally get set theory

The post also highlights new Set methods that operate on two sets at once: intersection, union, difference, symmetricDifference, isSubsetOf, isSupersetOf and isDisjointFrom. The author demonstrates with a skills-matching example, showing how one call can now answer questions such as which requirements overlap with an existing skill set and which are missing. Operations like these previously required manual filtering or a utility library.

Two long-awaited regex improvements

Regular expressions receive two updates. The first is RegExp.escape(), which the post says arrived at the end of a roughly 15-year effort. It solves the problem of embedding user-typed search text in a regex: characters like $ are special in patterns, and RegExp.escape() safely neutralizes them so a query such as a price string can be compiled without breaking. The second is per-group inline modifiers, which let case-insensitivity apply to only part of a pattern rather than the whole expression via the global i flag.

Promise.try unifies two error paths

For asynchronous code, the post covers Promise.try(), which simplifies handling functions that might either throw synchronously or reject asynchronously. Previously those cases needed a try/catch plus a separate .catch(); wrapping the call in Promise.try() funnels both failure modes into a single .catch().

Import attributes, with caveats

The author calls import attributes a personal favorite, chiefly for importing CSS alongside components — a stylesheet loaded with with { type: "css" } can be attached to a web component's shadow root via adoptedStyleSheets, keeping styles in real CSS files next to the component code.

JSON imports get a more cautious treatment. The post relays warnings from Jake Archibald's writing on importing versus fetching JSON: a failed JSON import can take the entire module graph down with it, a dynamic import() can catch the failure but returns less useful data than fetch(), and imported data stays resident in the module graph for the life of the page instead of becoming garbage-collectible. The author's conclusion is to tread carefully.

Why it matters

JavaScript's yearly release cadence means features arrive steadily but quietly, and many developers' habits were formed several editions ago. This roundup is useful as an audit checklist: iterator helpers reduce memory pressure in data-heavy code, the new Set methods and RegExp.escape() remove common sources of hand-rolled boilerplate and subtle bugs, and Promise.try() tidies up error handling. Just as importantly, the piece models the right posture toward new syntax — enthusiasm tempered by checking the failure and memory semantics, as the JSON import discussion shows. Adopting a language feature is not only about convenience at the call site; it changes how errors propagate and how long data lives in memory.