DEV Community

7 New JavaScript Features (And 2 I'm Still Waiting For)

Sylwia Laskowska on June 24, 2026

Remember how I promised you (or rather myself) two weeks ago that from now on I'd only write light, easy posts? Well… I broke that promise 😅 Last w...

Read full post

Pascal CESCATO • Jun 24

But today is finally the day for something a bit lighter.

Lighter?🤔
Hmm… interesting, for sure. Lighter? Depends on your own javascript skills.

And about inclusion in the Top 7 Posts of the Week: the post deserves it, you deserve it. It was really interesting.

Sylwia Laskowska • Jun 24

Thanks, Pascal! Yeah... I think something went slightly wrong with the "lighter" part of this post. Maybe next week I'll finally manage to write something truly lightweight. 😅

And you're right about the migration post. Writing the article itself took quite a while, but compared to preparing the conference talk, that was the easy part! There was a lot of research, testing, refining examples, and trying to distill years of migration lessons into something useful and practical.

So I'm especially happy to see that people found it valuable. 😊

Pascal CESCATO • Jun 24

What you are seeing—and what I see too—is that hard work still pays off: gathering sources, doing your research, incorporating your own knowledge, and pulling it all together—all of this contributes to the richness of an in-depth article and to the recognition of your work, whether through the comments you receive, inclusion in the "Top 7 of the Week," or in many other ways.

Sylwia Laskowska • Jun 24

Exactly! 😄 Maybe it doesn't make us any richer, but at least we get to have great conversations with interesting people in the comments. And that's one of the best parts of writing. 😊

Daniel Balcarek • Jun 24

Nice, it looks like JS is slowly catching up with “real” languages like C#. 😄🤪 Just joking, of course. 😄

But honestly, Temporal.Now.instant() and using features look amazing. Having them in JS would be great. I hope we get them next year.

Sylwia Laskowska • Jun 24

Haha, exactly! 😄 We're getting closer to the "real languages" every year.

Though honestly, JavaScript will never fully get there, because we'd have to break half the web to do it. 😂

Temporal should make it into ES2027 without much drama, but using is still only at Stage 3, so we'll see. I'm keeping my fingers crossed though!

Ingo Steinke, web developer • Jun 26

The Great Absentees: like, every year they keep adding new features and syntactical sugar to JS/ECMAScript, and every year they avoid strong typing. And JS and CSS syntax still moves forward too quickly for real end user devices to catch up, especially given Apple's planned obsolescence while banning third-party browser engines on old iPhones.

I mostly ignore "new features in JavaScript", "new features in CSS", "new frameworks", "new anything" hype train now. Array.fromAsync sounds promising though.

Sylwia Laskowska • Jun 26

Haha, I know exactly what you mean. 😄 But I still love reading about new JavaScript features anyway. Every time I do, I'm reminded of how much we struggled with some of these things 10 years ago. 😅

As for strong typing... I've pretty much given up on that ever happening in JavaScript. Even TC39's stance seems to be: "The most we can do is some pseudo-types, but never at runtime." 😂

Ingo Steinke, web developer • Jun 26 • Edited

I agree. I mean, there is JSDoc, and there is TypeScript. I used C0ffeeScript and jQuery and mootools back then. And ActionScript. We really shouldn't complain!

Sylwia Laskowska • Jun 26

Wow! This stack brings some unpleasant memories 🤣

Hemapriya Kanagala • Jun 24

Sylwia, I can tell a lot of work went into this one 😄

I'm not that deep into JavaScript myself, but I still learned a few things from this. It's easy to forget that the language keeps evolving while everyone is busy talking about AI these days.

Thanks for sharing this.

Sylwia Laskowska • Jun 24

Thank you so much! 😊

That's always my goal: to make technical topics approachable and easy to digest, even for people who don't work with JavaScript every day. I'm really glad you found something useful in it!

Daniel Nwaneri • Jun 24

The getOrInsert addition is the one I've been waiting for . That pattern of checking has() then set() then get() shows up everywhere in agent memory implementations and it's always felt like boilerplate that shouldn't exist. Math.sumPrecise() is the other one worth flagging for anyone doing token budget calculations where floating point drift compounds across requests. Good breakdown — the TC39 repository dig on Temporal was worth it.

Sylwia Laskowska • Jun 24

Thanks, Daniel! 😊 That's a great example.

To me, it really shows how these features are catching up with the reality of modern development and helping us write code that's a better fit for today's AI- and agent-driven applications, instead of relying on the same old boilerplate patterns.

Jack Lee • Jun 24

JavaScript has always felt like a premature baby.
Back in the early days, every project was a collection of hacks, browser quirks, polyfills, and "don't touch this code" comments. Many of today's features aren't innovations so much as missing pieces that should have existed from the beginning.
The surprising thing is not how much JavaScript has changed, but how long it took to grow up.

Sylwia Laskowska • Jun 24

Exactly! 😄 That's actually one of the reasons I've been on a bit of a crusade in my articles lately: making people aware that many of the hacks and workarounds we've used for years simply aren't needed anymore.

And as for the missing pieces... well, what can we expect from a loosely typed language that was famously created in about a week? 😂

buildbasekit • Jun 25

Absolutely. It's funny how the biggest productivity gains often come from removing little bits of friction instead of introducing huge new features. Less boilerplate usually means less code to maintain, review, and debug. 😄

Sylwia Laskowska • Jun 26

Exactly! 😄 And I'm a little jealous, to be honest.

Back when everything was harder, I wrote tons of code. Now that I'm a lead, I spend much less time coding, and on top of that, LLMs write a fair amount of it too. 😂

And of course, now all these nice little quality-of-life features are finally arriving!

Adam - The Developer • Jun 24 • Edited

awesomeeeeee!! this is my favorite now btw:

const meeting =
  Temporal.ZonedDateTime.from(
    "2026-11-03T10:00:00[Europe/Warsaw]"
  );

Sylwia Laskowska • Jun 24

Exactly! 😄 A brave new world where dates actually make sense. 😂

Jack Schmidt • Jun 26

Imagine having something like this back in the vanilla days... 😄 Though honestly, who still wires up events by hand these days?

function scopedListeners() {
  const ctrl = new AbortController();
  return {
    signal: ctrl.signal,
    [Symbol.dispose]() { ctrl.abort(); }
  };
}

{
  using l = scopedListeners();
  button.addEventListener("click", onClick, { signal: l.signal });
  button.addEventListener("mousemove", onMove, { signal: l.signal });
} // <- all listeners gone, automatically

Sylwia Laskowska • Jun 26

Haha, this code is beautiful. 🩷 And I wouldn't underestimate vanilla JavaScript. I think a lot more people still wire up events by hand than we sometimes realize. 😀

Mohit Patel • Jun 25

thanks for sharing ...

Mario Valle • Jun 25

Thanks for this article! Maybe adding that everything is not yet in NodeJS could have helped containing my enthusiasm 😁
Anyway, Could you help clarifying the difference between const takes = await Array.fromAsync(opinions); and the usual const takes = await Promise.all(opinions);?
Thanks!

Sylwia Laskowska • Jun 25

Sure! As for Array.fromAsync() vs Promise.all(), they look similar at first glance, but there's an important difference. Promise.all() resolves all promises concurrently, and Array.fromAsync() awaits each element sequentially as it builds the array.

Sylwia Laskowska • Jun 25

Thank you ☺️

𝑻𝒉𝒆 𝑳𝒂𝒛𝒚 𝑮𝒊𝒓𝒍 • Jun 24

Wow, absolutely loved this breakdown! JavaScript is evolving so beautifully, and these ES2026 features are exactly what we needed. Map.prototype.getOrInsert() is an absolute game-changer for reducing boilerplate and boilerplate map checks, and the performance benefits of Iterator.concat() without memory bloat are huge. Love the witty examples and the tone of the article—makes complex updates so digestible and fun to read. Can't wait to start refactoring my code with these. Thanks for this amazing write-up!!!!

Sylwia Laskowska • Jun 24

Thank you so much! 😊

That's exactly the goal: raising awareness of what's already available in the language, so people don't end up pulling in entire libraries for things JavaScript can now do out of the box. 😄

And honestly, some of these additions may look small, but over time they can remove a surprising amount of boilerplate from our codebases.

jacob foster • Jun 26

Congratulations on making the Top 7. AI gets attention, but evolving JavaScript and ECMAScript features matter just as much. Small language improvements consistently make code cleaner, simpler, and more maintainable.

Sylwia Laskowska • Jun 26

Exactly! That's why I enjoy writing about these features.

Michal Kindl • Jun 30

After reading your "lighter" article I am kinda afraid of looking at your "havier" stuff😉... but I definitely do so 😎.
To the Temporal topic: we have been dependent on moment.js and alternatives for too long...assuming the maturity of JavaScript language, it deserves built-in proper Date/Time handling.
Keep up the good work 👍️

Sylwia Laskowska • Jun 30

Thank you! 😄

And I completely agree about Moment.js. It's funny because even the Moment.js team now recommends not using it for new projects. 😅

If someone has been using Moment for years and wants a sensible alternative without changing too many habits, I usually recommend Luxon. And, of course, now we finally have Temporal making its way into JavaScript itself.

Ragner_R • Jun 25 • Edited

Greetings from Tallinn! Thanks so much for this fantastic overview—it’s always refreshing to see how the language is maturing to handle these edge cases without needing extra dependencies.
I actually develop JavaScript web-based games as a side project, so I really appreciate the detailed insight here. Diving into your list, I’m already brainstorming how to integrate some of these into my own engine architecture:

** Map.prototype.getOrInsert() / Upsert: ** This looks like it will be incredibly useful for managing entity components or tracking spatial grid objects in my engine, as it will cut down on the manual "check-if-exists-or-create" boilerplate I currently use for every new collision check.

** Iterator.concat(): ** This could be a very clean way to handle entity management, such as combining active-object streams from different "levels" or "zones" into a single, lazy iterator for the physics update loop without creating new arrays and hitting memory overhead.

** Math.sumPrecise(): ** This is a big one for physics simulations. Even with simple engines, floating-point drift can ruin consistent frame-timing or accumulation math over time; having a built-in way to handle accurate summation could save me some headaches with high-precision physics calculations.

Base64 for Uint8Array: This is going to make handling binary asset data or saving game state snapshots significantly more elegant when I need to serialize data for transmission or storage.

Thanks again for the great read—it definitely gives me a few things to optimize in my next build. I'm currently refining the physics loop for my own project, so this was perfect timing! :)

Sylwia Laskowska • Jun 25

Greetings to Tallinn from Gdańsk! 😄

Thank you so much for such a thoughtful comment! Reading concrete examples like yours honestly makes writing these articles worth it.

That's exactly why I write them, to inspire people and help them discover features they can immediately apply to real projects. It was really fun reading through your ideas for a game engine, and I hope some of these features end up making your code a little cleaner and simpler.

Good luck with the physics loop, and I'd love to hear how it goes!

Frank • Jun 25

I'm curious if one of the "waiting

Sylwia Laskowska • Jun 25

I guess you missed something in this comment? 😅

Michal Kindl • Jun 30

No, I think this is the practical example of awaiting concat of two infinite iterators...😉

Sylwia Laskowska • Jun 30

🤣🤣🤣

Maria andrew • Jun 26

Excellent write-up! What stood out to me wasn't just the list of ES2026 features, but how you connected each one to real development pain points. Map.getOrInsert() and Error.isError() may look like small additions, but they'll remove a surprising amount of repetitive code over time. And I completely agree Temporal feels like the feature JavaScript developers have been waiting years for. Thanks for turning a technical topic into such an enjoyable read! 👏

Sylwia Laskowska • Jun 26

Thank you so much! 😊 Yes, that was exactly my goal. Anyone can read the MDN docs, but... well, documentation isn't exactly the most exciting read. 😄

Mr Shuvo • Jun 26

Thanks.. It is usefull..

Evan Lausier • Jun 24

uggh... server date offsets. The worst!

Sylwia Laskowska • Jun 24

Haha, true! 😄 Always. ALWAYS. In every single project. 😂

Alex Shev • Jun 27

The best part of these JavaScript updates is when they remove small everyday friction rather than adding cleverness. Features that make normal code easier to read and refactor tend to matter more over time than syntax that only looks exciting in examples.

Mudassir Khan • Jun 29

the getOrInsert one is the feature i didn't know i needed. we build agent memory structures where the "check has() then set() then get()" pattern shows up in every tool result accumulator. boilerplate is low enough nobody flags it, but it compounds.

Math.sumPrecise() is worth flagging for token budget tracking — floating point drift compounds when summing per call token counts across hundreds of requests against quota thresholds. small numbers, real bugs.

on Temporal: the ZonedDateTime example is exactly why i want it. scheduled pipelines plus timezones is still "pick one and pray." 2027 can't come fast enough.

planning a followup on iterator helpers? Iterator.concat is nice but the full helpers API feels underexplored.

Arpit Mishra • Jun 27

Interesting read! JavaScript continues to evolve at an impressive pace, and these new features show how the language is becoming more powerful and developer-friendly. It's always exciting to see what makes coding easier today while still waiting for those long-requested features to finally arrive. The future of JavaScript looks promising, and developers have plenty to look forward to.

Elmar Chavez • Jun 27

I really like the Math.sumPrecise() one. Been doing some calculations in my past projects and sometimes I just want the assurance that the result would not suddenly become a floating/decimal number.

I'm also looking forward for the temporal update. I had this web app called TickTock and I used date-fns-tz for making sure the date and time are correct. It was demanding to understand third-party API's. I just hope it comes out in ECMA2027, it will make JS/TS developers' job way easier.

Louis Liu • Jun 25

Thank you for sharing this! I learned something new!

Sylwia Laskowska • Jun 25

Awww thanks 💖

Samir • Jun 29

Great read, great work Sylwia 🧡

Vishwajeet Kondi • Jun 28

The language isn't getting radically different anymore, it's just getting harder to justify utility libraries.
That's probably the biggest shift over the last few years.