JavaScript Version Changes

JavaScript Version Changes


3 min read

Table of contents

JavaScript has undergone several changes and updates over the years, with new versions introducing new features, improvements, and bug fixes. Here are some of the most notable changes in the history of JavaScript versions:

  1. ECMAScript 1 (ES1): The first version of ECMAScript was released in 1997 and included basic features like variables, functions, and control structures.

  2. ECMAScript 2 (ES2): The second version of ECMAScript was released in 1998 and included minor changes and improvements.

  3. ECMAScript 3 (ES3): ECMAScript 3 was released in 1999 and introduced several new features, such as try/catch exception handling, regular expressions, and support for JSON.

  4. ECMAScript 4 (ES4): ES4 was proposed but never officially released due to disagreements among developers over the scope and direction of the update.

  5. ECMAScript 5 (ES5): Released in 2009, ES5 introduced several new features, including strict mode, which enforced stricter rules for writing JavaScript code, and new array methods like map, filter, and reduce.


     var numbers = [1, 2, 3, 4, 5];
     var squaredNumbers = {
       return num * num;
     console.log(squaredNumbers); // [1, 4, 9, 16, 25]
  6. ECMAScript 6 (ES6): Also known as ECMAScript 2015, ES6 was a major update that introduced many new features, including arrow functions, classes, modules, and enhanced object literals.


     // ES5 function
     var square = function(num) {
       return num * num;
     // ES6 arrow function
     var square = (num) => num * num;
  7. ECMAScript 7 (ES7): Released in 2016, ES7 introduced several new features, including the exponential operator, Array.prototype.includes(), and the Object.values() and Object.entries() methods.

    ES7 introduced the exponential operator (**), which provides a shorthand for performing exponentiation.


     var squared = 2 ** 2; // 4
     var cubed = 2 ** 3; // 8
  8. ECMAScript 8 (ES8): Released in 2017, ES8 introduced new features such as async/await functions, Object.getOwnPropertyDescriptors(), and string padding methods.


     async function getUsers() {
       var response = await fetch('');
       var data = await response.json();
       return data;
  9. ECMAScript 9 (ES9): Released in 2018, ES9 introduced several new features, including rest and spread properties, asynchronous iteration, and Promise.prototype.finally().


     // Rest parameters
     function sum(...numbers) {
       return numbers.reduce((acc, curr) => acc + curr, 0);
     console.log(sum(1, 2, 3)); // 6
     // Spread syntax
     var numbers = [1, 2, 3];
     var newNumbers = [...numbers, 4, 5];
     console.log(newNumbers); // [1, 2, 3, 4, 5]
  10. ECMAScript 10 (ES10): Released in 2019, ES10 introduced several new features, including Array.prototype.flat() and Array.prototype.flatMap(), optional catch binding, and Object.fromEntries().


    var nestedNumbers = [1, [2, [3, 4]]];
    var flatNumbers = nestedNumbers.flat(2);
    console.log(flatNumbers); // [1, 2, 3, 4]
    var words = ['hello', 'world'];
    var flattenedWords = words.flatMap(word => word.split(''));
    console.log(flattenedWords); // ['h', 'e', 'l', 'l', 'o', 'w', 'o', 'r', 'l', 'd']

These are just a few examples of the changes introduced in different versions of JavaScript. Each version has introduced many new features and improvements that have made it easier to write efficient and maintainable code.

Since ES6, new versions of ECMAScript have been released annually, with each version introducing new features and improvements to the language. Developers can use tools like Babel and TypeScript to write code that uses newer features while maintaining compatibility with older browsers that do not support the latest version of ECMAScript.

Follow for more

Figma Community:
Personal Portfolio:

Thank you!

Did you find this article valuable?

Support Prahlad Inala by becoming a sponsor. Any amount is appreciated!