Current/Latest: https://tc39.es/ecma262/multipage/#sec-intro

  1. ECMAScript 5 (ES5):
    • Released in 2009.
    • Major improvements like strict mode, JSON support, and new array/object methods.
  2. ECMAScript 6 (ES6) / ECMAScript 2015:
    • Released in 2015.
    • A massive overhaul introducing features like let, const, arrow functions, classes, modules, promises, and much more.

ES6, also known as ES2015, marks the beginning of annual ECMAScript updates. Every year since then, there has been a new version with incremental improvements. Here’s the brief list of ECMAScript versions and their release years:

  • ECMAScript 5 (ES5): 2009
  • ECMAScript 6 (ES6/ES2015): 2015
  • ECMAScript 7 (ES2016): 2016
  • ECMAScript 8 (ES2017): 2017
  • ECMAScript 9 (ES2018): 2018
  • ECMAScript 10 (ES2019): 2019
  • ECMAScript 11 (ES2020): 2020
  • ECMAScript 12 (ES2021): 2021
  • ECMAScript 13 (ES2022): 2022
  • ECMAScript 14 (ES2023): 2023
  • DRAFT ECMA-262/ Sept 6, 2024: UNKNOWN

History of Javascript Name

From https://javascript.tm/.

The JavaScript trademark is currently held by Oracle America, Inc.
In 1995, Netscape partnered with Sun Microsystems to create interactive websites. Brendan Eich famously spent only 10 days creating the first version of JavaScript.
In 2009, Oracle acquired Sun Microsystems and the JavaScript trademark as a result.

In 1996, Netscape announced a meeting of the ECMA International standards organization to standardize the JavaScript programming language. Sun (now Oracle), refused to give up the “JavaScript” mark for this use though, so it was decided that the language would be called “ECMAScript” instead.

ECMA is short for European Computer Manufacturers Association.

ECMAScript Versions:

1. ECMAScript 1 (ES1)

  • Release Year: 1997
  • Key Features: First edition of ECMAScript, established the foundation for the language. Introduced basic syntax, types, objects, and control structures.

2. ECMAScript 2 (ES2)

  • Release Year: 1998
  • Key Features: A minor update to keep the language aligned with the ISO/IEC 16262 international standard.

3. ECMAScript 3 (ES3)

  • Release Year: 1999
  • Key Features:
    • Major update introducing regular expressions, try/catch exception handling, do-while loops, and more robust string handling.
    • This version set the stage for wide browser support and was the de facto version for many years.

4. ECMAScript 4 (ES4)

  • Status: Never officially released
  • Details: This version was planned to be a major overhaul with many new features, but it was deemed too ambitious, and the version was never completed. The ideas were scrapped or integrated into later versions.

5. ECMAScript 5 (ES5)

  • Release Year: 2009
  • Key Features:
    • Introduced strict mode, which allows for better error checking and more predictable behavior.
    • JSON support was natively added.
    • New Array methods like forEach(), map(), filter(), reduce(), and some().
    • Object methods: Object.create(), Object.keys(), and Object.defineProperty() introduced to improve object manipulation.
    • Property descriptors: Allowed developers to control properties more precisely with getter and setter functions.
    • This was the first significant update after a decade and is still widely used in many environments.

6. ECMAScript 6 (ES6) / ECMAScript 2015 (ES2015)

  • Release Year: 2015
  • Key Features:
    • Let and Const: Block-scoped variable declarations.
    • Arrow functions: A shorter syntax for writing functions (() => {}).
    • Classes: Introduced a more readable class syntax for creating objects and inheritance.
    • Template literals: A new way to write multi-line strings and embed expressions (${expression}).
    • Modules: Introduced import and export for JavaScript modularity.
    • Promises: Introduced for handling asynchronous operations more elegantly than callbacks.
    • Destructuring: Unpacking arrays or objects into variables (const {a, b} = obj).
    • Default parameters: Allowed function parameters to have default values.
    • Spread and Rest operators: Simplified working with arrays and objects.
    • Generators: Functions that can be paused and resumed, which helps with async programming.
    • This version was the biggest update in JavaScript’s history and revolutionized modern JavaScript development.

7. ECMAScript 7 (ES7) / ECMAScript 2016

  • Release Year: 2016
  • Key Features:
    • Array.prototype.includes(): Added a simpler way to check if an array contains a value.
    • Exponentiation operator (**): Introduced for simpler exponentiation (e.g., 2 ** 3 instead of Math.pow(2, 3)).

8. ECMAScript 8 (ES8) / ECMAScript 2017

  • Release Year: 2017
  • Key Features:
    • Async/Await: Made working with Promises easier and synchronous-like.
    • Object.entries() and Object.values(): Simplified ways to work with objects.
    • String padding (padStart() and padEnd()).

9. ECMAScript 9 (ES9) / ECMAScript 2018

  • Release Year: 2018
  • Key Features:
    • Asynchronous iteration: Using for await...of for handling async operations inside loops.
    • Rest/Spread properties for objects.

10. ECMAScript 10 (ES10) / ECMAScript 2019

  • Release Year: 2019
  • Key Features:
    • Array.prototype.flat() and flatMap(): Flatten arrays up to a certain depth.
    • Optional catch binding: No need to explicitly bind the error parameter in try/catch blocks.
    • Object.fromEntries(): Converts an array of key-value pairs into an object.

11. ECMAScript 11 (ES11) / ECMAScript 2020

  • Release Year: 2020
  • Key Features:
    • Nullish coalescing operator (??): Provides default values for null or undefined.
    • Optional chaining (?.): Simplifies access to deeply nested properties.
    • BigInt: Supports arbitrarily large integers.
    • Promise.allSettled(): Returns results when all promises have settled (resolved or rejected).

12. ECMAScript 12 (ES12) / ECMAScript 2021

  • Release Year: 2021
  • Key Features:
    • Logical assignment operators: Combines logical operations with assignment (e.g., &&=, ||=, ??=).
    • String.prototype.replaceAll(): Replaces all occurrences of a substring.
    • WeakRefs: Allows access to weakly held objects without preventing garbage collection.
<
Previous Post
Sudo Without Password
>
Next Post
How can I tell Adblock Plus that I’ve already paid?