JavaScript Features You Should Be Using in 2026

Most articles about JavaScript in 2026 focus on framework trends, AI tooling, and meta-framework choices. That’s useful context, but it leaves a gap: what’s actually new in the language itself that you can start using today?

Several features that became widely available across browsers during 2024–2025 solve real problems with less code. Here’s what’s now stable enough to use in production.

Object.groupBy() and Map.groupBy()

Grouping arrays by a property used to mean reaching for reduce() or a utility library. The ES2024 grouping methods make this a one-liner.

const products = [
  { name: 'Widget', category: 'hardware' },
  { name: 'Plugin', category: 'software' },
  { name: 'Gadget', category: 'hardware' },
]

const grouped = Object.groupBy(products, (p) => p.category)
// { hardware: [...], software: [...] }

Use Map.groupBy() when your keys aren’t strings or when you need Map semantics. Support has landed across modern browsers and recent Node.js releases; you can check the current status on https://webstatus.dev/features/array-group.

New Set Methods: Union, Intersection, and Difference

One of the most practical modern additions is the expanded Set API. You can now compute set relationships directly, without writing helper functions.

const frontend = new Set(['HTML', 'CSS', 'JavaScript'])
const backend = new Set(['Python', 'JavaScript', 'SQL'])

frontend.intersection(backend)        // Set { 'JavaScript' }
frontend.union(backend)               // Set { 'HTML', 'CSS', 'JavaScript', 'Python', 'SQL' }
frontend.difference(backend)          // Set { 'HTML', 'CSS' }
frontend.symmetricDifference(backend) // Set { 'HTML', 'CSS', 'Python', 'SQL' }

Relational checks like .isSubsetOf(), .isSupersetOf(), and .isDisjointFrom() are included too. These methods are now widely available across modern browsers; see https://webstatus.dev/features/set-methods for current compatibility.

Iterator Helpers

Iterator helpers let you apply map, filter, take, and other transformations lazily — without converting to an array first. This is one of the more underused language improvements that started rolling out broadly in 2025.

function* numbers() {
  let n = 0
  while (true) yield n++
}

const firstFiveEvens = numbers()
  .filter((n) => n % 2 === 0)
  .take(5)
  .toArray()
// [0, 2, 4, 6, 8]

This avoids creating intermediate arrays and is especially useful when working with large or infinite sequences. Browser support is continuing to expand; you can track it at https://webstatus.dev/features/iterator-methods.

RegExp.escape()

Sanitizing user input before passing it into a RegExp constructor has always required a custom utility. RegExp.escape() is now a built-in solution.

const userQuery = 'price: $10.00 (sale)'
const pattern = new RegExp(RegExp.escape(userQuery))

Without escaping, characters like ., $, and ( would be interpreted as regex syntax. This small API addition removes the need for ad-hoc escaping utilities and improves the safety of dynamically constructed regular expressions. You can track browser support on https://webstatus.dev/features/regexp-escape.

Promise.try()

Promise.try() wraps a function — synchronous or asynchronous — and always returns a promise representing the result.

const p = Promise.try(() => mightThrowSync())

If the function throws, the returned promise is rejected. If it returns a value or another promise, that value becomes the fulfillment of the returned promise.

This makes it convenient when you want to start a promise chain from code that might be synchronous or asynchronous without worrying about wrapping logic manually. Current browser availability can be tracked at https://webstatus.dev/features/promise-try.

Import Attributes

The standardized syntax for loading non-JavaScript modules uses the with keyword, replacing the older assert keyword.

import data from './config.json' with { type: 'json' }

This is the current standardized form supported by modern browsers. The earlier assert syntax is no longer the preferred approach, so new code should use the with keyword when importing JSON or other module types. You can follow platform support for JSON modules (which includes JSON import attributes) at https://webstatus.dev/features/json-modules.

Conclusion

These aren’t proposals or experimental features. They’re stable, broadly supported, and available in production environments today. If your mental model of modern JavaScript still ends at optional chaining and async/await, it’s time for an update.

Start with Object.groupBy() and the new Set methods — they’re the easiest to drop into existing code and immediately reduce boilerplate. From there, explore iterator helpers for lazy data processing and Promise.try() for cleaner handling when starting promise-based workflows.

FAQs

Complete picture for complete understanding

Capture every clue your frontend is leaving so you can instantly get to the root cause of any issue with OpenReplay — the open-source session replay tool for developers. Self-host it in minutes, and have complete control over your customer data.

Check our GitHub repo and join the thousands of developers in our community.