Understanding the Mechanism of an ES6 Function in Javascript

Block scope enables the redefinition of variables within nested blocks, such as functions, catch blocks, or explicit blocks. This syntax allows for modification of the contents of the variable x within the block and resets it upon leaving. With new features being added to JavaScript every year, it’s important to stay updated and understand how to implement ES6 JavaScript on your website.

ES6 JavaScript.

JavaScript has had to keep up with the evolving interactive web. As a result, new features are constantly being added to JavaScript every year. In this article, we will explore the latest additions and how to use ES6 JavaScript on your website.

JavaScript Has Many Flavors

The term “JavaScript” is trademarked by Oracle. Therefore, the modern implementation of JavaScript follows the ECMAScript standard, also known as ES. The most widely used standard for JavaScript is ECMAScript 5 (ES5), which was released in 2009 and is supported by all browsers, including IE 9. ES5 is essentially vanilla JavaScript without any additional features.

ES6, also known as ES2015, was introduced in 2015 and comes with a host of new features. Subsequent annual releases are identified by their release year, but despite this technicality, the name ES6 has stuck around and is still commonly used.

The significance of ES6 lies in its role as the beginning of JavaScript’s restandardization, which is now an annual occurrence by ECMA. However, ES6 stands out as a major milestone since it was released 6 years after ES5 and 10 years after ES3.

How to Use ES6 Syntax

ES6 is widely supported except for Internet Explorer. Therefore, while it is possible to use ES6 syntax, there is no guarantee of consistent browser behavior among all users.


At present, the common practice is to utilize a tool like Babel to transform the development code, written in ES6 with its advanced features, into “regular” ES5 syntax. Babel is a compiler that compiles the code, often bundled and minified with Webpack, which will ultimately run on your production website.

To explain the process, firstly, you need to have your development environment where you can write your


files. You have the liberty to utilize any ES6 syntax that suits your need. Instead of running them directly, you can configure Webpack to load JS files with Babel. Typically, when you make changes, you may want to run webpack-dev-server, which will automatically perform this operation for you.

Instead of loading


, you can now load


, which includes all of your code. This approach offers the added advantage of using NPM modules in your JS, but be mindful of adding too many as it could make your code bulky. However, webpack is an excellent tool for minification.

What’s New

Given the amount of information, this article may not cover all aspects. To access a complete list, you can refer to the compatibility table that encompasses ES2016 and beyond characteristics.

Typically, if Babel is capable of transpiling code to an earlier version of JavaScript, it should be suitable for developmental use. Alternatively, if IE 11’s 3% usage rate is not a concern, newer features are likely supported by most browsers.

Arrow Functions

Rather than typing:

arr.map(function (d) {
  return d + 1;

Instead of using the function keyword, you have the option to replace it with an arrow that comes after the parentheses.

arr.map((d) => {
  return d + 1;


In case of passing only one argument, parentheses become optional. Similarly, if only one value is to be returned, brackets and return statement can be omitted.

arr.map(d => d + 1);

The latest syntax for expression closures enables the creation of functions that are more concise, particularly when dealing with lists, callbacks, and error management. This approach is comparable to the way single line


statements operate.

Simplified Object and Array Creation With Destructuring

Rather than writing:

var type = "123", color = "blue"
var obj = { type: type, color: color }

It is possible to exclude the names of the keys, which will result in them being set to the names of the variables automatically.

var obj = { type, color }

Moreover, the converse of this process is known as destructuring assignment.

var { type, color } = obj

Destructuring offers a sophisticated benefit with the


structure that works as a substitute for “etc.” and assigns the remaining values of an array or object to a variable.

var { type, ...rest } = obj

//rest == { color: "blue" }

Additionally, it functions inversely and leads to the expansion and flattening of arrays.

var arr1 = ["a", "b"], arr2 = ["c", "d"]
var flat = [...a, ...b, "e"]

//flat = ["a", "b", "c", "d", "e"]

There’s a lot more to destructuring than what has been discussed in this context.


Mozilla’s documentation explains how JavaScript’s class implementation operates.

class Rectangle {
  constructor(height, width) {
    this.height = height;
    this.width = width;
  // Getter
  get area() {
    return this.calcArea();
  // Method
  calcArea() {
    return this.height * this.width;

const square = new Rectangle(10, 10);

console.log(square.area); // 100


This language is comparable to other object-oriented ones, however, not entirely identical as per Mozilla. The new system merely adds syntactic sugar over
JavaScript’s existing prototype-based inheritance
and does not truly transform JS into an object-oriented language. Nevertheless, it is still a beneficial feature.

The class syntax not only allows for static methods and properties, but also supports child classes. However, it is not possible for a child class to inherit from multiple parents.

Changes To Function Arguments

In ES6, there are two different methods for defining function parameters. The first method allows for default parameters to be set by assigning a value within the function definition.

var func = (a, b = "default") => {  }

In case you fail to provide two arguments while calling


, it will consider the default value.

The rest function parameters syntax enables functions to receive an array of arguments without any limit on the number of arguments.

var func = (a, b, c, ...rest) => {  }


The value of the


parameter will be an array consisting of the remaining function parameters, except when only the named parameters are available, in which case it will be



let and const



function replaces


and provides block scope for variables in JavaScript. Typically, variables work in JavaScript without block scope.

var x = 0; //global variable

function someFunc() {
  var y = 3; //local variable


The function can access the global variable, while the local function variable is restricted to the function. This enables the practice of repeatedly using names such as ”


“, ”


“, ”


“, and ”


” for variables without causing conflicts.

The block scope is distinct as it permits the redefinition of variables within nested blocks.

var x = 0

  let x = 2
    //x == 2
// x == 0 again



syntax enables alteration of the x contents within the block, whether it is a function, a catch block, or an explicit block. The variable resetting occurs when the block is exited, making it ideal for temporary variables, also known as ”


” variables. Each block has a distinct scope, which is useful for nesting and changing the scope in child blocks.

The syntax for


is easy to understand. Just substitute




to make your variable read-only. Any attempt to write to it will result in an error being thrown.

Uncaught TypeError: Assignment to constant variable.


Informing you that you are attempting to perform an unauthorized action. The sole purpose of this is to serve as a helpful prompt during coding to avoid potential errors.

Frequently Asked Questions