On this article, we’ll discover a number of the most fun and hotly anticipated JavaScript options which are anticipated to land in 2024.

The next proposals stand a great likelihood of creating it into this 12 months’s model of ECMAScript:

Desk of Contents

ECMAScript Updates

A brand new model of JS at all times causes a stir. Because the ES6 replace there was a brand new model yearly, and we’re anticipating this 12 months’s (ES2024) to land round June.

ES6 was an enormous launch that got here six years after its predecessor, ES5. Browser distributors and JavaScript builders have been overwhelmed with the sheer variety of new options to undertake and study. Since then, to forestall such a giant drop of recent options occurring directly, there’s been a yearly launch cycle.

This yearly launch cycle includes proposing any new options, that are then mentioned, evaluated, then voted on by a committee earlier than they’re added to the language. This course of additionally permits browsers to attempt to implement the proposals earlier than they’re formally added to the language, which can assist iron out any implementation issues.

As talked about, new options for JavaScript (or ECMAScript) are determined by Technical Committee 39 (TC39). TC39 is made up of representatives from all the most important browser distributors in addition to JavaScript consultants. They meet commonly to debate new options for the language and the way they are often applied. The brand new options are put ahead as proposals (made by anybody) and the committee members then vote on whether or not every proposal can transfer ahead to the following stage. There are 4 Phases for every proposal; as soon as a proposal reaches Stage 4, it’s anticipated to be included within the subsequent model of ES.

An necessary a part of the ES specification is that it needs to be backwards appropriate. Which means that any new options can’t break the Web by altering how earlier variations of ES labored. To allow them to’t change how current strategies work, they’ll solely add new strategies, as any web site working with a doubtlessly pre-existent methodology can be liable to breaking.

The complete record of all the present proposals could be seen here.


Within the State of JS 2022 survey, the third commonest reply to “What do you’re feeling is presently lacking from JavaScript?” was Higher Date Administration.

This has led to the Temporal proposal, which gives a typical world object to interchange the Date object and fixes various the problems which have induced builders a lot ache when working with dates in JavaScript over time.

Working with dates in JavaScript is nearly at all times a dreaded job; having to take care of small however infuriating inconsistencies, such because the craziness of months being zero-indexed however days of the month beginning at 1.

The problem of dates has resulted in common libraries comparable to Moment, Day.JS and date-fns popping as much as attempt to repair the problems. Nevertheless, the Temporal API goals to repair all the issues natively.

Temporal will help a number of time-zones and non-Gregorian calendars out of the field, and can present a simple-to-use API that may make it a lot simpler to parse dates from strings. Moreover, all Temporal objects can be immutable, which can assist keep away from any unintentional date change bugs.

Let’s take a look at some examples of essentially the most helpful strategies supplied by the Temporal API.


Temporal.Now.Instantaneous() will return a DateTime object to the closest nanosecond. You possibly can specify specific dates utilizing the from methodology like so:

const olympics = Temporal.Instantaneous.from('2024-07-26T20:24:00+01:00');

It will create a DateTime object that represents the beginning of the Paris Olympics later this 12 months at 20:24 on the twenty sixth July 2024 (UTC).


This lets you create only a date, with no time:

new Temporal.PlainDate(2024, 7, 26);



As a complement to PlainDate(), we will use this to create only a time with no date, utilizing .PlainTime():

new Temporal.PlainTime(20, 24, 0);



PlainMonthDay() is just like PlainDate, nevertheless it solely returns the month and day with no 12 months info (helpful for dates that recur on the identical day yearly, comparable to Christmas Day and Valentine’s Day):

const valentinesDay = Temporal.PlainMonthDay.from({ month: 2, day: 14 });


Equally, there’s additionally PlainYearMonth that may return simply the 12 months and month (helpful for representing a complete month of a 12 months):

const march = Temporal.PlainYearMonth.from({ month: 3, 12 months: 2024 });


There are a variety of calculations that may be accomplished with Temporal objects. You possibly can add and subtract numerous items of time to a date object:

const right this moment = Temporal.Now.plainDateISO();

const lastWeek = right this moment.subtract({ days: 7});

const nextWeek = right this moment.add({ days: 7 });

The till and since strategies allow you to learn the way a lot time till a sure date or for the reason that date occurred. For instance, the next code will let you know what number of days it’s till the Paris Olympics:



These strategies return a Temporal.Length object that can be utilized to measure an period of time that has quite a few completely different items and rounding choices.

You possibly can extract the 12 months, month and day from a Date object and the hours, minutes, seconds, milliseconds, microseconds and nanoseconds type a Time object (microseconds and nanoseconds aren’t accessible within the present DateTime object). For instance:

<< 20

There are additionally different properties comparable to dayOfWeek (returns 1 for Monday and 7 for Sunday), daysInMonth (returns 28,29,30 or 31 relying on the month) and daysinYear (returns 365 or 366 relying on a intercalary year).

Temporal date objects may also have a examine methodology that can be utilized to order dates utilizing numerous sorting algorithms.

Temporal is presently a Stage 3 proposal that’s within the technique of being applied by browser distributors, so it appears as if its time has come (pun meant). You possibly can see the complete documentation here. There’s additionally a helpful cookbook of use circumstances here. When paired with the Intl.DateTimeFormat API you’ll be capable of do some very nifty date manipulation.

Pipe Operator

Within the State of JS 2022 survey, the sixth prime reply to “What do you’re feeling is presently lacking from JavaScript?” was a Pipe Operator.

You possibly can see the Pipe Operator proposal here.

A pipe operator is a typical characteristic in purposeful languages that permits you to “pipe” a price from one operate to a different, with the output of the earlier operate getting used because the enter to the following (in the same method that the Fetch API passes any information it returns from one promise to the following).

For instance, say we wished to consecutively apply three features to a string:

  1. Concatenate the string “Pay attention up!” to the start of the unique string.
  2. Concatenate three exclamation marks onto the top of the string.
  3. Make all of the textual content higher case.

These three features could possibly be written as follows:

const exclaim = string => string + "!!!"
const pay attention = string => "Pay attention up! " + string
const uppercase = string => string.toUpperCase()

These three features could possibly be utilized by nesting all of them collectively as follows:

const textual content = "Good day World"

uppercase(exclaim(pay attention(textual content)))

However deeply nesting a number of operate calls like this will get messy in a short time, particularly for the reason that worth (textual content) being handed as an argument finally ends up deeply embedded contained in the expression, making it troublesome to determine.

The opposite drawback with operate nesting is that the order the features are utilized in is again to entrance, in that the inner-most features are utilized first. So on this case, pay attention will get utilized to the unique worth of textual content, adopted by exclaim, then the outer-most operate, uppercase, can be utilized final of all. Significantly for giant and sophisticated features, this turns into laborious and unintuitive to comply with.

An alternate is to make use of operate chaining like this:

const textual content = "Good day World"

textual content.pay attention().exclaim().uppercase()

This solves a variety of issues from nested features. The argument being handed is originally, and every operate seems within the order it’s utilized in, so pay attention() is utilized first, then exclaim() then uppercase().

Sadly, this instance gained’t work, as a result of the pay attention, exclaim and uppercase features aren’t strategies of the String class. They could possibly be added by monkey patching the String class, however that is usually frowned on as a way.

Which means that, though chaining appears to be like rather a lot higher than operate nesting, it may possibly solely actually be used with built-in features (as is often accomplished with Array strategies).

Piping combines the benefit of use of chaining however with the flexibility to make use of it with any features. Underneath the present proposal, the instance above can be written like so:

 textual content |> pay attention(%) |> exclaim(%) |> uppercase(%)

The % token is a placeholder used to characterize the worth of the output of the earlier operate, though it’s extremely probably that the % character can be changed by another character within the official launch. This permits for features that settle for multiple argument for use alongside the pipeline.

Piping combines the benefit of chaining however can be utilized with any customized features that you just’ve written. The one situation is that it’s worthwhile to be certain that the output sort of 1 operate matches the enter sort of the following operate within the chain.

Piping works finest with curried functions that solely settle for a single argument that’s piped from the return worth of any earlier operate. It makes purposeful programming a lot simpler, as small, building-block features could be chained collectively to make extra complicated composite features. It additionally makes partial application simpler to implement.

Regardless of its recognition, the pipe operator has struggled to maneuver ahead past Stage 2 of the method. This is because of disagreements over how the notation must be expressed and considerations over reminiscence efficiency and the way it would possibly work with await. It appears that evidently the committee is slowly reaching some type of settlement, although, so hopefully the pipe operator would possibly transfer shortly via the phases and make an look this 12 months.

Fortunately, the pipeline operator has been implemented in Babel from version 7.15.

Personally, we might love the pipe operator to be applied and rolled out this 12 months, as it might actually assist enhance the credentials of JavaScript as a critical purposeful programming language.

Information and Tuples

The Record and Tuple proposal goals to convey immutable information buildings to JavaScript.

Tuples are just like arrays — an ordered record of values — however they’re deeply immutable. Which means that each worth in a tuple should both be a primitive value or one other report or tuple (not arrays or objects, as a result of they’re mutable in JavaScript).

A tuple is created in the same strategy to an array literal, however with a number one hash image (#) on the entrance:

const heroes = #["Batman", "Superman", "Wonder Woman"]

As soon as this has been created, no different values could be added and no values could be eliminated. The values can’t be modified both.

Information are just like objects — a set of key-value pairs — however they’re additionally deeply immutable. They’re created in the same strategy to an object — however in the identical method as tuples, they begin with a number one hash:

const traitors = #{
  diane: false,
  paul: true,
  zac: false,
  harry: true

Information will nonetheless use the dot notation to entry properties and strategies:

<< true

And the sq. bracket notation that arrays use may also be used for tuples:

<< "Superman"

However since they’re immutable, you may’t replace any of the properties:

traitors.paul = false
<< Error

heroes[1] = "Supergirl"
<< Error

The immutability of tuples and data signifies that you’ll be capable of examine them simply utilizing the === operator:

heroes === #["Batman", "Superman", "Wonder Woman"];
<< true

One factor to notice is that the order of properties doesn’t matter when contemplating the equality of data:

traitors === #{
  ross: false,
  zac: false,
  paul: true,
  harry: true

<< true

The order does matter for tuples, although, as they’re an ordered record of knowledge:

heroes === #["Wonder Woman", "Batman", "Superman"];
<< false

This page has a useful tutorial with a reside playground so you may get used to how data and tuples will work.

RegExp /v flag

Common expressions have been integrated in JavaScript since model 3, and there have been quite a few enhancements since then (comparable to Unicode help utilizing the u flag in ES2015). The v flag proposal goals to do every little thing the u flag does, nevertheless it provides some further advantages that we’ll take a look at within the examples beneath.

Merely, implementing the v flag includes including a /v to the top of your common expression.

For instance, the next code can be utilized to check if a personality is an emoji:

const isEmoji = /^p{RGI_Emoji}$/v;
<< true

<< true

This makes use of the RGI_Emoji sample to determine emojis.

The v flag additionally permits you to use set notation in your common expressions. For instance, you may subtract one sample from one other utilizing the -- operator. The next code can be utilized to take away any love hearts from the set of emojis:

const isNotHeartEmoji = /^[p{RGI_Emoji_Tag_Sequence}--q{💜💚♥️💙🖤💛🧡🤍🤎}]$/v;

<< false

<< true

Yow will discover the intersection of two patterns utilizing &&. For instance, the next code will discover the intersection of Greek symbols and letters:

const GreekLetters = /[p{Script_Extensions=Greek}&&p{Letter}]/v;

<< true

<< false

The v flag additionally irons out some points that the u flag had with case insensitivity as effectively, making it a significantly better choice to make use of in virtually all circumstances.

The v flag for normal expressions reached Stage 4 throughout 2023 and has been applied in all main browsers, so it’s totally anticipated to be a part of the ES2024 specification.


The Decorator proposal goals to make use of decorators to increase JavaScript lessons natively.

Decorators are already widespread in lots of object-oriented languages such as Python and have already been included in TypeScript. They’re a typical metaprogramming abstraction that permits you to add further performance to a operate or class with out altering its construction. For instance, you would possibly need to add some further validation to a technique, and you might do that by making a validation decorator that checks the information entered right into a type.

While JavaScript helps you to use features to implement this design sample, most object-oriented programmers would favor an easier and native method of attaining this, merely to make life a lot simpler.

The proposal provides some syntactic sugar to let you simply implement a decorator inside a category with out having to consider binding this to the category. It supplies a a lot cleaner method of extending class components, comparable to class fields, class strategies, or class accessors, and it may possibly even be utilized to the entire class.

Decorators are recognized with a prefix of the @ image and are at all times positioned instantly earlier than the code they’re “adorning”.

For instance, a category decorator will come instantly earlier than the category definition. Within the instance beneath, the validation decorator is utilized to the entire of the FormComponent class:

class FormComponent {

operate validation(goal) {

A category methodology decorator comes instantly earlier than the tactic it decorates. Within the instance beneath, the validation decorator is utilized to the submit methodology:

class FormComponent {

  submit(information) {

operate validation(goal) {

Decorator operate definitions settle for two parameters: a price and context. The worth argument refers back to the worth being embellished (for instance a category methodology) and the context comprises metadata concerning the worth, comparable to if it’s a operate or not, its title, and if it’s static or non-public. You may also add an initializer operate to the context that can be run when a category is instantiated.

The Decorator proposal is presently in Stage 3 and has been implemented in Babel, so you may already strive it out.


So what do you assume? What would you wish to see added to the spec this 12 months? All these options will make nice additions to JavaScript, so fingers crossed they’ll make it on this 12 months!