.JS File Format – Versions

Editions

Since 2015, an edition has been published each year and named after that year. The sixth edition is known both as ES6 and as ES2015.

How features are added

Proposals move through the numbered stages of the TC39 process, and a proposal that reaches stage 4 is written into the next edition. Engines often ship a feature before the edition that contains it is published.

ES1 (June 1997)

The first edition standardised the language as implemented in browsers of the time: types and objects with prototypes, functions, var, the if, while, for, for…in, with and return statements, and the core objects Object, Function, Array, String, Boolean, Number, Math and Date.

ES2 (June 1998)

An editorial revision to keep the standard aligned with ISO/IEC 16262, approved in April 1998. The language did not change.

ES3 (December 1999)

• Regular expressions, with RegExp and the string methods that use them.
• New control statements: do-while, switch and labels.
• try, catch, finally and throw, with the standard Error types.
• Object and array literals, and function expressions.
• ===, !==, in and instanceof.
• Numeric formatting: toFixed, toExponential and toPrecision.
• Array methods such as push, pop and splice, and the URI functions.

ES4 (abandoned)

Work on a fourth edition was never completed or published. Some of its ideas went into the sixth edition.

ES5 and ES5.1 (December 2009, June 2011)

• Strict mode.
• Accessor properties and property attributes, with Object.defineProperty.
• Reflective creation and inspection: Object.create, Object.keys, Object.getPrototypeOf, Object.freeze and others.
• Array methods: forEach, map, filter, reduce, indexOf and others.
• The JSON object.
• Function.prototype.bind, String.prototype.trim, Date.now and the debugger statement.
• Reserved words as property names, and trailing commas in object literals.

Edition 5.1 made minor corrections, and is the same text as ISO/IEC 16262:2011.

ES2015 (June 2015)

The sixth edition was the largest update to the language.

• let, const and block scope.
• Arrow functions, default and rest parameters, spread, destructuring.
• class, including extends and super.
• Modules, with import and export.
• Iterators, for…of and generators.
• Template literals, shorthand and computed object keys, binary and octal literals, \u{…} escapes.
• Symbol, Map, Set, WeakMap, WeakSet, Promise, Proxy and Reflect.
• Typed arrays, ArrayBuffer and DataView.
• u and y regular expression flags.
• Tail calls.

ES2016

• The exponentiation operator **.
• Array.prototype.includes.

ES2017

• Async functions and await.
• SharedArrayBuffer, Atomics and the memory model.
• Object.values, Object.entries and Object.getOwnPropertyDescriptors.
• padStart, padEnd, and trailing commas in parameter and argument lists.

ES2018

• Async iteration: for await and async generators.
• Rest and spread for object properties.
• Promise.prototype.finally.
• Regular expressions: the s flag, named groups, Unicode property escapes and lookbehind.
• Tagged templates may contain invalid escapes.

ES2019

• flat, flatMap, Object.fromEntries, trimStart, trimEnd and Symbol.prototype.description.
• Optional catch binding.
• U+2028 and U+2029 allowed in string literals, so JSON is a subset of the language.
• Array.prototype.sort must be stable, and JSON.stringify must return well-formed text.
• Function.prototype.toString revised to return source text.

ES2020

• BigInt.
• Optional chaining ?. and nullish coalescing ??.
• import(), import.meta and export * as ns from.
• globalThis, matchAll and Promise.allSettled.
• A more fully specified for…in order.

ES2021

• Logical assignment: &&=, ||= and ??=.
• Numeric separators.
• replaceAll, Promise.any and AggregateError.
• WeakRef and FinalizationRegistry.

ES2022

• Top-level await in modules.
• Public and private fields, private methods and accessors, static blocks, and #x in obj.
• The d flag for match indices.
• cause on errors, at, and Object.hasOwn.

ES2023

• toSorted, toReversed, with, findLast, findLastIndex and toSpliced.
• Hashbang comments.
• Most symbols allowed as keys in weak collections.

ES2024

• Resizable and transferable ArrayBuffer, and growable SharedArrayBuffer.
• The v regular expression flag.
• Promise.withResolvers, Object.groupBy and Map.groupBy.
• Atomics.waitAsync, isWellFormed and toWellFormed.

ES2025

• The Iterator global and iterator helpers.
• New Set methods.
• Import attributes and JSON modules.
• RegExp.escape, modifier groups and duplicate named groups.
• Promise.try.
• Float16Array, Math.f16round, and the DataView methods for it.

ES2026

• Math.sumPrecise.
• Iterator.concat and Array.fromAsync.
• Error.isError.
• getOrInsert and getOrInsertComputed on Map and WeakMap.
• Uint8Array conversion to and from base64 and hex.
• Source text access in JSON.parse revivers, and JSON.rawJSON.

The current draft (ES2027)

The draft at tc39.es/ecma262 is the eighteenth edition. It already includes these proposals, which have finished the process:

• using and await using, with Symbol.dispose, Symbol.asyncDispose, DisposableStack, AsyncDisposableStack and SuppressedError.
• Iterator additions: Iterator.zip, Iterator.zipKeyed, chunks, windows, includes and join.
• Atomics.pause.

Temporal has also finished the process, with ES2027 as its expected edition, but was not in the text of the draft at the time of writing.

Compatibility between editions

New editions are designed not to break existing code on the web. Annexes E and F of ECMA-262 list the few changes that have an observable effect on older programs. Features kept only for old pages are in Annex B.