What’s New in JavaScript? A Complete Guide to ES5‑ES10 and Future Proposals

ECMAScript Evolution Overview

JavaScript follows the ECMAScript specification. Since ES5 (published in 2009) the language has received yearly updates: ES6 (ES2015), ES7 (ES2016), ES8 (ES2017), ES9 (ES2018), ES10 (ES2019) and later proposals. Each edition adds new syntax, built‑in objects, and APIs that become native in modern browsers. Proposals progress through TC39 stages 0‑4 before they are incorporated into the standard.

ES6 (ES2015) Core Features

Class syntax and inheritance

Module import/export

Generators

Template literals, arrow functions, Promise, const / let, destructuring, Map / Set, Symbol, etc.

class MyComponent extends React.Component {
  // ...
}

import * as React from 'react';
export default MyComponent;

function* fibonacci() {
  let pre = 0, cur = 1;
  while (true) {
    [pre, cur] = [cur, pre + cur];
    yield cur;
  }
}

ES7 (ES2016) Additions

Exponentiation operator:

base ** exponent

Array.prototype.includes

let result = array.includes(item); // true or false

ES8 (ES2017) and Later

Object.entries

/ Object.values String padding: padStart, padEnd Trailing commas in function parameter lists

Shared memory and atomic operations ( Atomics)

Async/Await

async function getUsers(url) {
  return ajax.get(url);
}
const response = await getUsers('/getUsers');
console.log(response); // no .then needed

These features reached Stage 4 and run natively in browsers such as Chrome, Edge, and Opera.

ES9 (ES2018) Highlights

Template literal revision – allows complex expressions inside template strings

Asynchronous iterators:

for await … of

Promise.finally

Object rest/spread destructuring (now an ES9 feature)

const myNewObject = {a, b, c, ...object};

ES10 (ES2019) Highlights

Array.prototype.flat

and

flatMap

Object.fromEntries

String.trimStart

/ trimEnd Optional catch binding: catch {} Improved

Function.prototype.toString

Symbol.description

BigInt for arbitrary‑precision integers

Unicode‑aware JSON.stringify Stable sort for arrays with equal keys

const array = [
  {key:2,value:'d'},
  {key:1,value:'a'},
  {key:1,value:'b'},
  {key:1,value:'c'}
];
array.sort((a,b) => a.key - b.key); // stable in modern engines

Rejected Proposals

Some proposals never reached Stage 4, for example Object.observe (removed due to performance concerns) and Cancelable Promise . The full list of inactive proposals is available at https://github.com/tc39/proposals/blob/master/inactive-proposals.md.

var obj = {foo:0, bar:1};
Object.observe(obj, changes => console.log(changes));
obj.baz = 2; // would have logged a change

Future Proposals (Stage 0‑3)

Observable – a revived version of Object.observe

String.replaceAll (Stage 3)

Unrestricted await – allow await outside async functions

Optional chaining (now Stage 4)

// Optional chaining example
const test = myObject?.a;

Babel: Do You Still Need It?

For projects targeting browsers newer than IE 11, Babel is generally unnecessary because all ES6‑ES9 features are natively supported. Skipping Babel reduces bundle size, speeds up builds, and can improve runtime performance by up to threefold. Use Babel only when legacy environments (e.g., IE 11) must be supported.

Conclusion

The JavaScript language has evolved rapidly, adding powerful syntax and APIs while preserving backward compatibility. Knowing which features are native and which require transpilation helps developers choose appropriate tooling, define browser‑support policies, and write efficient, maintainable code.