1. javascript
  2. /es6

ES6 JavaScript


ECMAScript 6 (ES6), also known as ECMAScript 2015, is one of the most important updates in JavaScript history. It introduced several new features and syntax improvements. From the introduction of new keywords like let and const to the introduction of arrow functions, classes, and promises, ES6 provided developers with a wider range of tools to work with and made the language more modern and flexible.

The JavaScript let

The let keyword was introduced in ES6 as a new way to declare variables. Unlike var, which is function-scoped, let is block-scoped. This means that variables declared with let are only accessible within the block they are defined in.

// Example of using let
if (true) {
    let x = 5;
    console.log(x); // Output: 5
console.log(x); // ReferenceError: x is not defined

The JavaScript const

The const keyword as an ES6 feature, is a way to declare variables that cannot be reassigned. A variable declared with const must be initialized with a value when it is declared.

// Example of using const
const PI = 3.14;
console.log(PI); // Output: 3.14
PI = 3.14159; // TypeError: Assignment to constant variable.

Arrow Functions

ES6 brought a new shorthand for writing functions, called arrow functions. Arrow functions have a more concise syntax and do not have their own this value.

// Example of using arrow functions
const numbers = [1, 2, 3, 4, 5];
const square = numbers.map(x => x * x);
console.log(square); // Output: [1, 4, 9, 16, 25]

JavaScript Rest Parameter and Spread Operator

As new features from ES6, the rest parameter allows us to represent an indefinite number of arguments as an array, while the spread operator allows us to expand an array into individual elements.

// Example of using the rest parameter
function add(...numbers) {
    return numbers.reduce((sum, number) => sum + number);
console.log(add(1, 2, 3)); // Output: 6

// Example of using the spread operator
const numbers1 = [1, 2, 3, 4];
const numbers2 = [5, 6, 7, 8];
const allNumbers = [...numbers1, ...numbers2];
console.log(allNumbers); // Output: [1, 2, 3, 4, 5, 6, 7, 8]

The for...of loop in ES6

The for...of loop allows us to iterate over iterable objects, such as arrays, strings, and maps.

// Example of using for...of
const colors = ["red", "green", "blue"];
for (const color of colors) {
// Output: red, green, blue

Map Objects

The Map object is a collection of key-value pairs. The keys can be any value, including functions, objects, and primitive types.

// Example of using Map
const map = new Map();
map.set("name", "John Doe");
map.set("age", 30);
console.log(map.get("name")); // Output: "John Doe"
console.log(map.get("age")); // Output: 30

Set Objects

ES6 also introduced the Set object, which is a collection of unique values. The values can be any type, including objects and primitive types.

// Example of using Set
const set = new Set();
console.log(set.size); // Output: 3


ES6 set in motion a more familiar class syntax for object-oriented programming in JavaScript. The class syntax is similar to that of other object-oriented languages such as Java and C#.

// Example of using Classes
class Person {
    constructor(name, age) {
        this.name = name;
        this.age = age;
sayHello() {
    console.log(`Hello, my name is ${this.name} and I am ${this.age} years old.`);
const person = new Person("John Doe", 30);
person.sayHello(); // Output: "Hello, my name is John Doe and I am 30 years old."


The Promise object is a way to handle asynchronous tasks in a more structured and predictable way. A Promise represents a task that will either resolve or reject and can be used to handle both success and error scenarios.

// Example of using Promises
const promise = new Promise((resolve, reject) => {
    setTimeout(() => {
        resolve("Hello, World!");
    }, 1000);
promise.then(message => console.log(message)); 
// Output: "Hello, World!" after 1 second

Default Parameter Values

ES6 presented the ability to set default parameter values for function arguments. This allows a function to be called with fewer arguments, and the missing arguments will be set to their default values.

// Example of default parameter values
function add(a = 0, b = 0) {
    return a + b;
console.log(add(1)); // Output: 1
console.log(add(1, 2)); // Output: 3

Template Literals

Template literals allow for easier string interpolation and multi-line strings.

// Example of template literals
const name = "John Doe";
const age = 30;
console.log(`Hello, my name is ${name} and I am ${age} years old.`); // Output: "Hello, my name is John Doe and I am 30 years old."

JavaScript Destructuring

ES6 introduced destructuring, which allows for extracting values from arrays and objects and assigning them to variables. This makes it easier to work with complex data structures.

// Example of destructuring an array
const colors = ["red", "green", "blue"];
const [firstColor, secondColor, thirdColor] = colors;
console.log(firstColor); // Output: "red"
console.log(secondColor); // Output: "green"
console.log(thirdColor); // Output: "blue"


ES6 brought several new features that greatly improved the power and expressiveness of the language. Whether you're a beginner or a seasoned developer who's getting accustomed to JavaScript, you should understand and familiarize yourself with the following:

  • ES6 made the language more modern and powerful by introducing several new features and syntax improvements.
  • The new keywords let and const provide better variable scoping options.
  • Arrow functions and classes provide more concise and expressive syntax.
  • Promises and new data structures like Map and Set make it easier to handle async tasks and work with data.
  • The introduction of the import and export keywords makes it easier to manage and organize the codebase.