{"id":4144,"date":"2024-10-17T17:00:55","date_gmt":"2024-10-17T17:00:55","guid":{"rendered":"https:\/\/algocademy.com\/blog\/javascript-versions-a-comprehensive-guide-to-the-evolution-of-ecmascript\/"},"modified":"2026-10-15T12:51:17","modified_gmt":"2026-10-15T12:51:17","slug":"javascript-versions-a-comprehensive-guide-to-the-evolution-of-ecmascript","status":"publish","type":"post","link":"https:\/\/algocademy.com\/blog\/javascript-versions-a-comprehensive-guide-to-the-evolution-of-ecmascript\/","title":{"rendered":"JavaScript Versions: ECMAScript Editions from ES1 to ES2026"},"content":{"rendered":"

JavaScript is the language; ECMAScript is the standard that defines it. Each edition of the standard (ECMA-262) is a “JavaScript version”. Since ES2015 a new edition is approved every June, and the latest finished one is ECMAScript 2026 (the 17th edition, June 2026)<\/strong>. Names like “ES6” and “ES7” are older numbering for ES2015 and ES2016, so ES7 was released in June 2016.<\/p>\n

The sections below list every edition, when it came out, and what a working developer should know about it. The code examples were run on Node.js 22, so features newer than that are shown without output.<\/p>\n

ECMAScript editions at a glance<\/h2>\n

Dates are the editions listed on ecma-international.org<\/a>.<\/p>\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
Edition<\/th>\nName<\/th>\nReleased<\/th>\nHeadline additions<\/th>\n<\/tr>\n<\/thead>\n
1<\/td>\nES1<\/td>\nJune 1997<\/td>\nFirst standard<\/td>\n<\/tr>\n
2<\/td>\nES2<\/td>\n1998<\/td>\nEditorial alignment with ISO\/IEC 16262<\/td>\n<\/tr>\n
3<\/td>\nES3<\/td>\nDecember 1999<\/td>\nRegular expressions, try\/catch, do-while, switch<\/td>\n<\/tr>\n
4<\/td>\nES4<\/td>\nnever published<\/td>\nAbandoned<\/td>\n<\/tr>\n
5 \/ 5.1<\/td>\nES5<\/td>\nDecember 2009 \/ June 2011<\/td>\nStrict mode, JSON, array methods<\/td>\n<\/tr>\n
6<\/td>\nES2015 (ES6)<\/td>\nJune 2015<\/td>\nlet\/const, classes, modules, arrow functions, promises<\/td>\n<\/tr>\n
7<\/td>\nES2016 (ES7)<\/td>\nJune 2016<\/td>\n**<\/code>, Array.prototype.includes<\/code><\/td>\n<\/tr>\n
8<\/td>\nES2017<\/td>\nJune 2017<\/td>\nasync\/await, Object.entries<\/code><\/td>\n<\/tr>\n
9<\/td>\nES2018<\/td>\nJune 2018<\/td>\nObject rest\/spread, async iteration, Promise.finally<\/code><\/td>\n<\/tr>\n
10<\/td>\nES2019<\/td>\nJune 2019<\/td>\nflat<\/code>, flatMap<\/code>, Object.fromEntries<\/code><\/td>\n<\/tr>\n
11<\/td>\nES2020<\/td>\nJune 2020<\/td>\n?.<\/code>, ??<\/code>, BigInt, Promise.allSettled<\/code><\/td>\n<\/tr>\n
12<\/td>\nES2021<\/td>\nJune 2021<\/td>\nreplaceAll<\/code>, ??=<\/code>, Promise.any<\/code><\/td>\n<\/tr>\n
13<\/td>\nES2022<\/td>\nJune 2022<\/td>\nClass fields, private fields, top-level await, at()<\/code><\/td>\n<\/tr>\n
14<\/td>\nES2023<\/td>\nJune 2023<\/td>\ntoSorted<\/code>, findLast<\/code>, hashbang<\/td>\n<\/tr>\n
15<\/td>\nES2024<\/td>\nJune 2024<\/td>\nObject.groupBy<\/code>, Promise.withResolvers<\/code><\/td>\n<\/tr>\n
16<\/td>\nES2025<\/td>\nJune 2025<\/td>\nSet methods, iterator helpers, Promise.try<\/code><\/td>\n<\/tr>\n
17<\/td>\nES2026<\/td>\nJune 2026<\/td>\nArray.fromAsync<\/code>, Error.isError<\/code>, Math.sumPrecise<\/code><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

JavaScript vs ECMAScript<\/h2>\n

JavaScript was created at Netscape in 1995. It was handed to Ecma International for standardization, and because “JavaScript” was a trademark, the standard got the name ECMAScript. Browsers and runtimes (V8 in Chrome and Node.js, SpiderMonkey in Firefox, JavaScriptCore in Safari) are separate implementations that ship a feature on their own schedule.<\/p>\n

Two things follow from that. A feature is “in JavaScript” for practical purposes only when the engines you target support it, so check the compatibility tables on MDN<\/a>. And a proposal becomes part of an edition only when it reaches stage 4 in TC39, the committee that maintains the language. Proposals that are still at earlier stages (decorators, pattern matching) are not part of any edition.<\/p>\n

How the naming changed<\/h2>\n

Editions 1 to 6 were numbered. ES4 was abandoned, which is why ES5 follows ES3. With the 6th edition the committee switched to a yearly release and named editions by year, so ES6 became ES2015<\/strong>, ES7 became ES2016<\/strong>, and so on. Both names are still in use, but the year form is the official one. When someone says “ES7”, they mean ES2016, which is a small release with two features.<\/p>\n

ES1 to ES3 (1997 to 1999)<\/h2>\n

ES1 defined the basic syntax, types and core objects such as Array<\/code>, Date<\/code> and Math<\/code>. ES2 was an editorial update. ES3 added regular expressions, try\/catch<\/code>, do-while<\/code> and switch<\/code>. For years, ES3 was what every browser could be trusted to run.<\/p>\n

ES5 (2009, revised 2011)<\/h2>\n

ES5 arrived after a decade without a new edition. It added strict mode (\"use strict\"<\/code>), the built-in JSON<\/code> object, the array methods forEach<\/code>, map<\/code>, filter<\/code>, reduce<\/code>, some<\/code> and every<\/code>, Object.keys<\/code>, Object.create<\/code>, Object.freeze<\/code> and Function.prototype.bind<\/code>. It is the baseline that legacy code and old browsers still target.<\/p>\n

ES2015 (ES6): the big one<\/h2>\n

ES2015 changed how JavaScript is written. It added let<\/code> and const<\/code>, arrow functions, classes, template literals, destructuring, default and rest parameters, the spread operator, Promise<\/code>, Map<\/code> and Set<\/code>, Symbol<\/code>, iterators and generators, and the import<\/code>\/export<\/code> module syntax. If you only learn one edition well, learn this one. The lesson on constants<\/a> covers the const<\/code> part.<\/p>\n

const greet = name => `Hello, ${name}!`;\nconst { name, ...rest } = { name: \"Alice\", age: 30, city: \"Oslo\" };\n\nconsole.log(greet(\"Alice\"), name, rest);\n\/\/ Hello, Alice! Alice { age: 30, city: 'Oslo' }<\/code><\/pre>\n
(The object form of ...rest<\/code> used here arrived later, in ES2018; array rest and spread are ES2015.)<\/p>\n
ES2016 (ES7): two features<\/h2>\n
The exponentiation operator **<\/code> and Array.prototype.includes()<\/code>. That is the whole edition, which is why “ES7 features” searches turn up so little.<\/p>\n
console.log(2 ** 3, [1, 2, 3].includes(2));\n\/\/ 8 true<\/code><\/pre>\n
ES2017 (ES8): async\/await<\/h2>\n
async<\/code>\/await<\/code> lets you write promise-based code in a straight line. The edition also added Object.values()<\/code>, Object.entries()<\/code>, padStart()<\/code>, padEnd()<\/code>, Object.getOwnPropertyDescriptors()<\/code>, trailing commas in function parameter lists, and SharedArrayBuffer<\/code>\/Atomics<\/code>.<\/p>\n
console.log(Object.entries({ a: 1, b: 2 }), \"7\".padStart(3, \"0\"));\n\/\/ [ [ 'a', 1 ], [ 'b', 2 ] ] 007<\/code><\/pre>\n
For how promises and the event loop actually run this code, see the JavaScript Promise guide<\/a> and the event loop guide<\/a>.<\/p>\n
ES2018 (ES9)<\/h2>\n
Rest and spread properties for objects, asynchronous iteration (for await...of<\/code>), Promise.prototype.finally()<\/code>, and regex improvements: named capture groups, lookbehind, the s<\/code> (dotAll) flag and Unicode property escapes.<\/p>\n
ES2019 (ES10)<\/h2>\n
Array.prototype.flat()<\/code> and flatMap()<\/code>, Object.fromEntries()<\/code>, trimStart()<\/code> and trimEnd()<\/code>, optional catch<\/code> binding (catch { }<\/code> without a variable), and a requirement that Array.prototype.sort<\/code> be stable.<\/p>\n
console.log([1, [2, [3, [4]]]].flat(Infinity), Object.fromEntries([[\"a\", 1]]));\n\/\/ [ 1, 2, 3, 4 ] { a: 1 }<\/code><\/pre>\n
ES2020 (ES11)<\/h2>\n
Optional chaining ?.<\/code>, nullish coalescing ??<\/code>, BigInt<\/code>, Promise.allSettled()<\/code>, globalThis<\/code>, dynamic import()<\/code> and String.prototype.matchAll()<\/code>. The difference between ??<\/code> and ||<\/code> matters: ??<\/code> only falls back on null<\/code> and undefined<\/code>, so 0<\/code> and \"\"<\/code> are kept.<\/p>\n
console.log(null ?? \"default\", 0 ?? 42, ({ a: {} }).a?.b?.c, 2n ** 64n);\n\/\/ default 0 undefined 18446744073709551616n<\/code><\/pre>\n
ES2021 (ES12)<\/h2>\n
Logical assignment operators (||=<\/code>, &&=<\/code>, ??=<\/code>), numeric separators, String.prototype.replaceAll()<\/code>, Promise.any()<\/code>, and WeakRef<\/code> with FinalizationRegistry<\/code>.<\/p>\n
let a = null;\na ??= 10;\nconsole.log(a, \"a-b-c\".replaceAll(\"-\", \"_\"), 1_000_000);\n\/\/ 10 a_b_c 1000000<\/code><\/pre>\n
ES2022 (ES13)<\/h2>\n
Class fields, private fields and methods (#name<\/code>), static class fields and static blocks, top-level await<\/code> in modules, Array.prototype.at()<\/code>, Object.hasOwn()<\/code>, the cause<\/code> option for errors, and the regex d<\/code> flag (match indices).<\/p>\n
class Counter {\n  #n = 0;\n  static label = \"counter\";\n  inc() { this.#n++; return this.#n; }\n}\n\nconsole.log(new Counter().inc(), Counter.label, [1, 2, 3].at(-1), Object.hasOwn({ x: 1 }, \"x\"));\n\/\/ 1 counter 3 true\n\nconst err = new Error(\"outer\", { cause: new Error(\"inner\") });\nconsole.log(err.cause.message);\n\/\/ inner<\/code><\/pre>\n
Top-level await only works in ES modules (a .mjs<\/code> file, or \"type\": \"module\"<\/code> in package.json<\/code>):<\/p>\n
const data = await Promise.resolve({ ok: true });\nconsole.log(data);\n\/\/ { ok: true }<\/code><\/pre>\n
ES2023 (14th edition)<\/h2>\n
The main addition is the “change array by copy” group: toSorted()<\/code>, toReversed()<\/code>, toSpliced()<\/code> and with()<\/code>. They return a new array instead of mutating the original, which is what you want in React state or any code that avoids shared mutation. The edition also added findLast()<\/code> and findLastIndex()<\/code>, hashbang (#!<\/code>) comment syntax, and symbols as WeakMap<\/code> keys.<\/p>\n
const nums = [3, 1, 2];\nconsole.log(nums.toSorted(), nums, nums.toReversed(), nums.with(0, 9), nums.findLast(n => n > 1));\n\/\/ [ 1, 2, 3 ] [ 3, 1, 2 ] [ 2, 1, 3 ] [ 9, 1, 2 ] 2<\/code><\/pre>\n
ES2024 (15th edition)<\/h2>\n
Grouping with Object.groupBy()<\/code> and Map.groupBy()<\/code>, Promise.withResolvers()<\/code>, resizable and transferable ArrayBuffer<\/code>s, Atomics.waitAsync()<\/code>, isWellFormed()<\/code> \/ toWellFormed()<\/code> on strings, and the regex v<\/code> flag.<\/p>\n
const people = [{ n: \"A\", age: 30 }, { n: \"B\", age: 25 }, { n: \"C\", age: 30 }];\nconsole.log(Object.groupBy(people, p => p.age));\n\/\/ [Object: null prototype] {\n\/\/   '25': [ { n: 'B', age: 25 } ],\n\/\/   '30': [ { n: 'A', age: 30 }, { n: 'C', age: 30 } ]\n\/\/ }\n\nconsole.log(\"ab\\uD800\".isWellFormed());\n\/\/ false<\/code><\/pre>\n
Object.groupBy<\/code> returns an object with a null<\/code> prototype, so it has no inherited keys like toString<\/code> to collide with your group names.<\/p>\n
ES2025 (16th edition)<\/h2>\n
New Set<\/code> methods (union<\/code>, intersection<\/code>, difference<\/code>, symmetricDifference<\/code>, isSubsetOf<\/code> and friends), iterator helpers (map<\/code>, filter<\/code>, take<\/code>, drop<\/code>, toArray<\/code> and more on iterators), Promise.try()<\/code>, RegExp.escape()<\/code>, regex modifiers and duplicate named capture groups, JSON modules with import attributes, and Float16Array<\/code>.<\/p>\n
console.log(new Set([1, 2, 3]).union(new Set([3, 4])));\n\/\/ Set(4) { 1, 2, 3, 4 }\n\nconsole.log([1, 2, 3, 4].values().filter(n => n % 2 === 0).map(n => n * 10).toArray());\n\/\/ [ 20, 40 ]<\/code><\/pre>\n
Iterator helpers are lazy: they process one item at a time instead of building intermediate arrays, which helps with large or infinite sequences.<\/p>\n
ES2026 (17th edition)<\/h2>\n
The edition approved in June 2026 adds, among other things:<\/p>\n