LuisLlamas Logo
javascript-versiones

JavaScript Versions

  • 5 min
  • Intermediate

Let’s review the main versions of JavaScript, with their most important improvements and modifications.

JavaScript has evolved a lot since its creation, especially since 2015. It is no longer the “amateur” language that was so criticized (it’s still criticized, but now with less reason).

With the different versions, it has become a much more formal and professional language, maintaining its own characteristics but incorporating new features that have brought it up to the level of a modern programming language.

So here is a list and their release dates.

  • JavaScript

    Evolution of the language since its creation

  • JavaScript 1.0

    Creation by Brendan Eich at Netscape

  • JavaScript 1.1

    First implementation in Netscape Navigator 3

  • ECMAScript 1

    First ECMAScript standard

  • ECMAScript 3 ⭐

    Major update

  • ECMAScript 5

    Strict mode and native JSON

  • ECMAScript 6 (ES6/ES2015) ⭐

    Massive update: let, const, classes, modules

  • ECMAScript 7 (ES2016)

    Includes and exponentiation

  • ECMAScript 8 (ES2017)

    async/await, Object.entries()

  • ECMAScript 9 (ES2018)

    Rest/Spread for objects

  • ECMAScript 10 (ES2019)

    flat(), flatMap(), trimStart()

  • ECMAScript 11 (ES2020)

    BigInt, nullish coalescing, Optional Chaining

  • ECMAScript 12 (ES2021)

    Promise.any(), logical assignment operators

  • ECMAScript 13 (ES2022)

    Top-level await, RegExp Match Indices

  • ECMAScript 14 (ES2023)

    Array improvements and WeakRefs

And here is a summary of the main features each version incorporates 👇.

Features by version

ECMAScript 1 (ES1) - 1997

  • First official version of the standard, establishing a solid foundation for the language.
  • Basic functions, control structures (if, while, for), operators, and native objects (Array, String, Date) were defined.

ECMAScript 2 (ES2) - 1998

  • Minor update that standardized technical specifications to align the standard with ISO/IEC 16262.
  • No significant functional changes to the language.

ECMAScript 3 (ES3) - 1999

  • Expansion of language functionality, including regular expressions, error handling with try...catch, and improvements in string handling.
  • Addition of Object, Array, and methods for advanced data manipulation.
  • Laid the groundwork for JavaScript in complex web applications.

ECMAScript 4 (ES4) - Canceled

  • Advanced features like static typing and classes were proposed, but the project did not reach consensus.
  • However, many ideas and proposals from ES4 formed the basis for future versions, especially ES6.

ECMAScript 5 (ES5) - 2009

  • Introduction of strict mode to improve code security and performance.
  • Functional methods in Array (map, forEach, filter, reduce, etc.).
  • New functionalities in Object like Object.create, Object.defineProperty, and Object.keys.
  • This version consolidated the use of JavaScript in modern web applications.

ECMAScript 5.1 (ES5.1) - 2011

  • Minor update that formalized corrections and standardized some implementations.
  • Became the basis for the ISO/IEC 16262:2011 standard.

ECMAScript 6 (ES6) - 2015

  • Introduction of let and const to improve variable scope control.
  • Arrow functions (=>) for shorter and more manageable syntax.
  • Classes and class inheritance to facilitate object-oriented programming.
  • Modules (import and export) allowing for better code organization and modularization.
  • Template literals (` `) for variable interpolation and string formatting.
  • Promises (Promise) to handle asynchronous operations in a structured way.

ECMAScript 7 (ES7) - 2016

  • Exponentiation operator (**), allowing concise expression of powers.
  • Array.prototype.includes method to check if an element is present in an array.

ECMAScript 8 (ES8) - 2017

  • async/await to simplify handling asynchronous operations.
  • Object.entries and Object.values methods to get values or key-value pairs from an object.
  • String padding (padStart and padEnd) for string manipulation.
  • Trailing commas in function parameters for better readability.

ECMAScript 9 (ES9) - 2018

  • Rest and spread operator (...) to facilitate handling objects and arrays.
  • Asynchronous iteration with for await...of, useful for working with asynchronous data streams.
  • Improvements in Promise handling, including Promise.finally.

ECMAScript 10 (ES10) - 2019

  • Array.prototype.flat and flatMap methods for working with multidimensional arrays.
  • Optional chaining operator (?.) to simplify access to nested properties.
  • Object.fromEntries method and improvements in String.prototype.matchAll.

ECMAScript 11 (ES11) - 2020

  • Nullish coalescing operator (??), which assigns a value only if it is null or undefined.
  • Promise.allSettled method to handle multiple promises and see the status of all.
  • WeakRefs and FinalizationRegistry for advanced memory management.
  • Optional chaining (?.), to simplify safe access to nested properties.

ECMAScript 12 (ES12) - 2021

  • String.prototype.replaceAll method to replace all matches in a string.
  • Logical assignment operators (&&=, ||=, ??=) to simplify conditional assignments.
  • Improvements in class manipulation and the definition of private fields (#).

ECMAScript 13 (ES13) - 2022

  • Top-level await, allowing the use of await in modules without needing to wrap in asynchronous functions.
  • Improvement in the use of iterators and generators.
  • Support for safer and more controlled comparison operators.

ECMAScript 14 (ES14) - 2023

  • Improvement in Array.prototype.with, which allows inserting elements into arrays without mutating them.
  • Symbol.asyncIterator to optimize asynchronous generators.
  • Optimization of logical operators to facilitate writing conditional logic.

On this page