Language: EN
LuisLlamas Logo
Search
⏲️ ~ 6 minutes Intermediate
javascript-versiones

JavaScript Versions

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

JavaScript has evolved significantly since its creation, especially since 2015. It is no longer the “kitchen sink” language that was often criticized (which, it is still criticized, but now with less reason).

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

So here you have a list and its release dates.

  • JavaScript

    Evolution of the language since its creation

  • JavaScript 1.0

    Created 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)

    Improvements in arrays and WeakRefs

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

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 in the language.

ECMAScript 3 (ES3) - 1999

  • Expanded functionality of the language, 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) - Cancelled

  • Advanced features like static typing and classes were proposed, but the project did not reach consensus.
  • However, many ideas and proposals from ES4 became 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 features in Object like Object.create, Object.defineProperty, and Object.keys.
  • This version solidified 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 of the ISO/IEC 16262:2011 standard.

ECMAScript 6 (ES6) - 2015

  • Inclusion 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) that allow for better organization and modularization of code.
  • Template literals (` `) for variable interpolation and string formatting.
  • Promises (Promise) to handle asynchronous operations in a structured way.

ECMAScript 7 (ES7) - 2016

  • Exponentiation operator (**), which allows for 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 the handling of asynchronous operations.
  • Object.entries and Object.values methods to obtain 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 of 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 methods 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 methods to handle multiple promises and see the status of all.
  • WeakRefs and FinalizationRegistry for advanced memory management.
  • Optional chaining option (?.) for safe access to nested properties.

ECMAScript 12 (ES12) - 2021

  • String.prototype.replaceAll methods 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.
  • Improved 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