EPeak Daily

ES5 to ESNext — right here’s each function added to JavaScript since 2015

0 35

I wrote this text that can assist you transfer from pre-ES6 data of JavaScript and get you rapidly on top of things with the newest developments of the language.

JavaScript in the present day is within the privileged place to be the one language that may run natively within the browser, and is extremely built-in and optimized for that.

The way forward for JavaScript goes to be good. Maintaining with the adjustments shouldn’t be more durable than it already is, and my purpose right here is to provide you a fast but complete overview of the brand new stuff out there to us.

Click on right here to get a PDF / ePub / Mobi model of this publish to learn offline

Desk of Contents

Introduction to ECMAScript






Introduction to ECMAScript

Everytime you examine JavaScript you’ll inevitably see one among these phrases: ES3, ES5, ES6, ES7, ES8, ES2015, ES2016, ES2017, ECMAScript 2017, ECMAScript 2016, ECMAScript 2015… what do they imply?

They’re all referring to a normal, referred to as ECMAScript.

ECMAScript is the usual upon which JavaScript relies, and it’s typically abbreviated to ES.

Beside JavaScript, different languages implement(ed) ECMAScript, together with:

  • ActionScript (the Flash scripting language), which is shedding reputation since Flash might be formally discontinued in 2020
  • JScript (the Microsoft scripting dialect), since on the time JavaScript was supported solely by Netscape and the browser wars have been at their peak, Microsoft needed to construct its personal model for Web Explorer

however in fact JavaScript is the hottest and broadly used implementation of ES.

Why this bizarre identify? Ecma Worldwide is a Swiss requirements affiliation who’s in control of defining worldwide requirements.

When JavaScript was created, it was introduced by Netscape and Solar Microsystems to Ecma they usually gave it the identify ECMA-262 alias ECMAScript.

This press launch by Netscape and Solar Microsystems (the maker of Java) may assist work out the identify selection, which could embrace authorized and branding points by Microsoft which was within the committee, in response to Wikipedia.

After IE9, Microsoft stopped branding its ES assist in browsers as JScript and began calling it JavaScript (not less than, I couldn’t discover references to it any extra).

In order of 201x, the one in style language supporting the ECMAScript spec is JavaScript.

Present ECMAScript model

The present ECMAScript model is ES2018.

It was launched in June 2018.

What’s TC39

TC39 is the committee that evolves JavaScript.

The members of TC39 are corporations concerned in JavaScript and browser distributors, together with Mozilla, Google, Fb, Apple, Microsoft, Intel, PayPal, SalesForce and others.

Each normal model proposal should undergo numerous levels, that are defined right here.

ES Variations

I discovered it puzzling why generally an ES model is referenced by version quantity and generally by yr, and I’m confused by the yr by probability being -1 on the quantity, which provides to the final confusion round JS/ES 😄

Earlier than ES2015, ECMAScript specs have been generally referred to as by their version. So ES5 is the official identify for the ECMAScript specification replace revealed in 2009.

Why does this occur? In the course of the course of that led to ES2015, the identify was modified from ES6 to ES2015, however since this was achieved late, folks nonetheless referenced it as ES6, and the group has not left the version naming behind — the world remains to be calling ES releases by version quantity.

This desk ought to clear issues up a bit:

Let’s dive into the precise options added to JavaScript since ES5. Let’s begin with the ES2015 options.

let and const

Till ES2015, var was the one assemble out there for outlining variables.

var a = 0

In the event you neglect so as to add var you can be assigning a price to an undeclared variable, and the outcomes may range.

In fashionable environments, with strict mode enabled, you’re going to get an error. In older environments (or with strict mode disabled) it will initialize the variable and assign it to the worldwide object.

In the event you don’t initialize the variable once you declare it, it would have the undefined worth till you assign a price to it.

var a //typeof a === 'undefined'

You possibly can redeclare the variable many occasions, overriding it:

var a = 1
var a = 2

You too can declare a number of variables directly in the identical assertion:

var a = 1, b = 2

The scope is the portion of code the place the variable is seen.

A variable initialized with var outdoors of any operate is assigned to the worldwide object, has a world scope and is seen in every single place. A variable initialized with var inside a operate is assigned to that operate, it is native and is seen solely inside it, similar to a operate parameter.

Any variable outlined in a operate with the identical identify as a world variable takes priority over the worldwide variable, shadowing it.

It’s necessary to know {that a} block (recognized by a pair of curly braces) doesn’t outline a brand new scope. A brand new scope is just created when a operate is created, as a result of var doesn’t have block scope, however operate scope.

Inside a operate, any variable outlined in it’s seen all through all of the operate code, even when the variable is asserted on the finish of the operate it may possibly nonetheless be referenced to start with, as a result of JavaScript earlier than executing the code really strikes all variables on high (one thing that known as hoisting). To keep away from confusion, at all times declare variables at the start of a operate.

Utilizing let

let is a brand new function launched in ES2015 and it is basically a block scoped model of var. Its scope is restricted to the block, assertion or expression the place it is outlined, and all of the contained inside blocks.

Trendy JavaScript builders may select to solely use let and utterly discard the usage of var.

If let appears an obscure time period, simply learn let shade = 'crimson' as let the colour be crimson and all of it makes far more sense

Defining let outdoors of any operate – opposite to var – doesn’t create a world variable.

Utilizing const

Variables declared with var or let could be modified in a while in this system, and reassigned. As soon as a const is initialized, its worth can by no means be modified once more, and it may possibly’t be reassigned to a unique worth.

const a = 'check'

We are able to’t assign a unique literal to the a const. We are able to nevertheless mutate a if it is an object that gives strategies that mutate its contents.

const doesn’t present immutability, simply makes certain that the reference cannot be modified.

const has block scope, identical as let.

Trendy JavaScript builders may select to at all times use const for variables that do not have to be reassigned later in this system, as a result of we should always at all times use the only assemble out there to keep away from making errors down the street.

Arrow Capabilities

Arrow features, since their introduction, modified ceaselessly how JavaScript code appears to be like (and works).

For my part this variation was so welcome that you simply now hardly ever see the utilization of the operate key phrase in fashionable codebases. Though that has nonetheless its utilization.

Visually, it’s a easy and welcome change, which lets you write features with a shorter syntax, from:

const myFunction = operate() {


const myFunction = () => {

If the operate physique comprises only a single assertion, you’ll be able to omit the brackets and write all on a single line:

const myFunction = () => doSomething()

Parameters are handed within the parentheses:

const myFunction = (param1, param2) => doSomething(param1, param2)

If in case you have one (and only one) parameter, you may omit the parentheses utterly:

const myFunction = param => doSomething(param)

Because of this quick syntax, arrow features encourage the usage of small features.

Implicit return

Arrow features let you have an implicit return: values are returned with out having to make use of the return key phrase.

It really works when there’s a one-line assertion within the operate physique:

const myFunction = () => 'check'
myFunction() //'check'

One other instance, when returning an object, keep in mind to wrap the curly brackets in parentheses to keep away from it being thought-about the wrapping operate physique brackets:

const myFunction = () => ({ worth: 'check' })
myFunction() //{worth: 'check'}

How this works in arrow features

this is an idea that may be difficult to understand, because it varies rather a lot relying on the context and in addition varies relying on the mode of JavaScript (strict mode or not).

It’s necessary to make clear this idea as a result of arrow features behave very otherwise in comparison with common features.

When outlined as a technique of an object, in an everyday operate this refers back to the object, so you are able to do:

const automotive = {
mannequin: 'Fiesta',
producer: 'Ford',
fullName: operate() {
return `${this.producer} ${this.mannequin}`

calling automotive.fullName() will return "Ford Fiesta".

The this scope with arrow features is inherited from the execution context. An arrow operate doesn’t bind this in any respect, so its worth might be seemed up within the name stack, so on this code automotive.fullName() won’t work, and can return the string "undefined undefined":

const automotive = {
mannequin: 'Fiesta',
producer: 'Ford',
fullName: () => {
return `${this.producer} ${this.mannequin}`

Attributable to this, arrow features aren’t suited as object strategies.

Arrow features can’t be used as constructors both, when instantiating an object will elevate a TypeError.

That is the place common features ought to be used as a substitute, when dynamic context isn’t wanted.

That is additionally an issue when dealing with occasions. DOM Occasion listeners set this to be the goal component, and in the event you depend on this in an occasion handler, an everyday operate is important:

const hyperlink = doc.querySelector('#hyperlink')
hyperlink.addEventListener('click on', () => {
// this === window
const hyperlink = doc.querySelector('#hyperlink')
hyperlink.addEventListener('click on', operate() {
// this === hyperlink


JavaScript has fairly an unusual technique to implement inheritance: prototypical inheritance. Prototypal inheritance, whereas in my view nice, is not like most different in style programming language’s implementation of inheritance, which is class-based.

Individuals coming from Java or Python or different languages had a tough time understanding the intricacies of prototypal inheritance, so the ECMAScript committee determined to sprinkle syntactic sugar on high of prototypical inheritance in order that it resembles how class-based inheritance works in different in style implementations.

That is necessary: JavaScript underneath the hood remains to be the identical, and you may entry an object prototype within the normal manner.

A category definition

That is how a category appears to be like.

class Particular person {
constructor(identify) {
this.identify = identify
  whats up() {
return 'Hey, I'm ' + this.identify + '.'

A category has an identifier, which we are able to use to create new objects utilizing new ClassIdentifier().

When the article is initialized, the constructor methodology known as, with any parameters handed.

A category additionally has as many strategies because it wants. On this case whats up is a technique and could be referred to as on all objects derived from this class:

const flavio = new Particular person('Flavio')
flavio.whats up()

Class inheritance

A category can lengthen one other class, and objects initialized utilizing that class inherit all of the strategies of each lessons.

If the inherited class has a technique with the identical identify as one of many lessons increased within the hierarchy, the closest methodology takes priority:

class Programmer extends Particular person {
whats up() {
return tremendous.whats up() + ' I'm a programmer.'
const flavio = new Programmer('Flavio')
flavio.whats up()

(the above program prints “Hey, I’m Flavio. I’m a programmer.”)

Courses do not need specific class variable declarations, however you could initialize any variable within the constructor.

Inside a category, you’ll be able to reference the guardian class calling tremendous().

Static strategies

Usually strategies are outlined on the occasion, not on the category.

Static strategies are executed on the category as a substitute:

class Particular person {
static genericHello() {
return 'Hey'
Particular person.genericHello() //Hey

Non-public strategies

JavaScript doesn’t have a built-in technique to outline personal or protected strategies.

There are workarounds, however I gained’t describe them right here.

Getters and setters

You possibly can add strategies prefixed with get or set to create a getter and setter, that are two totally different items of code which are executed primarily based on what you’re doing: accessing the variable, or modifying its worth.

class Particular person {
constructor(identify) {
this.identify = identify
  set identify(worth) {
this.identify = worth
  get identify() {
return this.identify

In the event you solely have a getter, the property can’t be set, and any try at doing so might be ignored:

class Particular person {
constructor(identify) {
this.identify = identify
  get identify() {
return this.identify

In the event you solely have a setter, you’ll be able to change the worth however not entry it from the surface:

class Particular person {
constructor(identify) {
this.identify = identify
  set identify(worth) {
this.identify = worth

Default parameters

It is a doSomething operate which accepts param1.

const doSomething = (param1) => {

We are able to add a default worth for param1 if the operate is invoked with out specifying a parameter:

const doSomething = (param1 = 'check') => {

This works for extra parameters as effectively, in fact:

const doSomething = (param1 = 'check', param2 = 'test2') => {

What you probably have an distinctive object with parameters values in it?

As soon as upon a time, if we needed to go an object of choices to a operate, with a view to have default values of these choices if one among them was not outlined, you had so as to add a bit little bit of code contained in the operate:

const colorize = (choices) => {
if (!choices) {
choices = {}
  const shade = ('shade' in choices) ? choices.shade : 'yellow'

With destructuring you’ll be able to present default values, which simplifies the code rather a lot:

const colorize = ({ shade = 'yellow' }) => {

If no object is handed when calling our colorize operate, equally we are able to assign an empty object by default:

const spin = ({ shade = 'yellow' } = {}) => {

Template Literals

Template Literals let you work with strings in a novel manner in comparison with ES5 and under.

The syntax at a primary look could be very easy, simply use backticks as a substitute of single or double quotes:

const a_string = `one thing`

They’re distinctive as a result of they supply quite a lot of options that standard strings constructed with quotes don’t, specifically:

  • they provide an ideal syntax to outline multiline strings
  • they supply a straightforward technique to interpolate variables and expressions in strings
  • they let you create DSLs with template tags (DSL means area particular language, and it’s for instance utilized in React by Styled Elements, to outline CSS for a element)

Let’s dive into every of those intimately.

Multiline strings

Pre-ES6, to create a string spanning over two traces you had to make use of the character on the finish of a line:

const string =
'first half
second half'

This permits to create a string on 2 traces, however it’s rendered on only one line:

first half second half

To render the string on a number of traces as effectively, you explicitly want so as to add n on the finish of every line, like this:

const string =
'first linen
second line'


const string = 'first linen' + 'second line'

Template literals make multiline strings a lot less complicated.

As soon as a template literal is opened with the backtick, you simply press enter to create a brand new line, with no particular characters, and it’s rendered as-is:

const string = `Hey
is superior!`

Remember the fact that area is significant, so doing this:

const string = `First

goes to create a string like this:


a straightforward technique to repair this drawback is by having an empty first line, and appending the trim() methodology proper after the closing backtick, which is able to eradicate any area earlier than the primary character:

const string = `


Template literals present a straightforward technique to interpolate variables and expressions into strings.

You accomplish that through the use of the ${...} syntax:

const var = 'check'
const string = `one thing ${var}` //one thing check

contained in the ${} you’ll be able to add something, even expressions:

const string = `one thing ${1 + 2 + 3}`
const string2 = `one thing ${foo() ? 'x' : 'y'}`

Template tags

Tagged templates is one function which may sound much less helpful at first for you, however it’s really utilized by a lot of in style libraries round, like Styled Elements or Apollo, the GraphQL consumer/server lib, so it’s important to know the way it works.

In Styled Elements template tags are used to outline CSS strings:

const Button = styled.button`
font-size: 1.5em;
background-color: black;
shade: white;

In Apollo template tags are used to outline a GraphQL question schema:

const question = gql`
question {

The styled.button and gql template tags highlighted in these examples are simply features:

operate gql(literals, ...expressions) {}

this operate returns a string, which could be the results of any sort of computation.

literals is an array containing the template literal content material tokenized by the expressions interpolations.

expressions comprises all of the interpolations.

If we take an instance above:

const string = `one thing ${1 + 2 + 3}`

literals is an array with two objects. The primary is one thing, the string till the primary interpolation, and the second is an empty string, the area between the tip of the primary interpolation (we solely have one) and the tip of the string.

expressions on this case is an array with a single merchandise, 6.

A extra advanced instance is:

const string = `one thing
one other ${'x'}
new line ${1 + 2 + 3}

on this case literals is an array the place the primary merchandise is:

;`one thing
one other `

the second is:

new line `

and the third is:


expressions on this case is an array with two objects, x and 6.

The operate that’s handed these values can do something with them, and that is the ability of this sort function.

The most straightforward instance is replicating what the string interpolation does, by becoming a member of literals and expressions:

const interpolated = interpolate`I paid ${10}€`

and that is how interpolate works:

operate interpolate(literals, ...expressions) {
let string = ``
for (const [i, val] of expressions) {
string += literals[i] + val
string += literals[literals.length - 1]
return string

Destructuring assignments

Given an object, you’ll be able to extract just a few values and put them into named variables:

const particular person = {
firstName: 'Tom',
lastName: 'Cruise',
actor: true,
age: 54, //made up
const {firstName: identify, age} = particular person

identify and age comprise the specified values.

The syntax additionally works on arrays:

const a = [1,2,3,4,5]
const [first, second] = a

This assertion creates Three new variables by getting the objects with index 0, 1, Four from the array a:

const [first, second, , , fifth] = a

Enhanced Object Literals

In ES2015 Object Literals gained superpowers.

Easier syntax to incorporate variables

As a substitute of doing

const one thing = 'y'
const x = {
one thing: one thing

you are able to do

const one thing = 'y'
const x = {
one thing


A prototype could be specified with

const anObject = { y: 'y' }
const x = {
__proto__: anObject


const anObject = { y: 'y', check: () => 'zoo' }
const x = {
__proto__: anObject,
check() {
return tremendous.check() + 'x'
x.check() //zoox

Dynamic properties

const x = {
['a' + '_' + 'b']: 'z'
x.a_b //z

For-of loop

ES5 again in 2009 launched forEach() loops. Whereas good, they provided no technique to break, like for loops at all times did.

ES2015 launched the for-of loop, which mixes the conciseness of forEach with the flexibility to interrupt:

//iterate over the worth
for (const v of ['a', 'b', 'c']) {
//get the index as effectively, utilizing `entries()`
for (const [i, v] of ['a', 'b', 'c'].entries()) {
console.log(index) //index
console.log(worth) //worth

Discover the usage of const. This loop creates a brand new scope in each iteration, so we are able to safely use that as a substitute of let.

The distinction with for...in is:

  • for...of iterates over the property values
  • for...in iterates the property names


A promise is usually outlined as a proxy for a price that may ultimately turn into out there.

Guarantees are one technique to take care of asynchronous code, with out writing too many callbacks in your code.

Async features use the guarantees API as their constructing block, so understanding them is key even when in newer code you’ll seemingly use async features as a substitute of guarantees.

How guarantees work, in transient

As soon as a promise has been referred to as, it would begin in pending state. Which means that the caller operate continues the execution, whereas it waits for the promise to do its personal processing, and provides the caller operate some suggestions.

At this level, the caller operate waits for it to both return the promise in a resolved state, or in a rejected state, however as you understand JavaScript is asynchronous, so the operate continues its execution whereas the promise does it work.

Which JS API use guarantees?

Along with your individual code and library code, guarantees are utilized by normal fashionable Internet APIs corresponding to:

It’s unlikely that in fashionable JavaScript you’ll end up not utilizing guarantees, so let’s begin diving proper into them.

Making a promise

The Promise API exposes a Promise constructor, which you initialize utilizing new Promise():

let achieved = true
const isItDoneYet = new Promise((resolve, reject) => {
if (achieved) {
const workDone = 'Right here is the factor I constructed'
} else {
const why = 'Nonetheless engaged on one thing else'

As you’ll be able to see the promise checks the achieved world fixed, and if that is true, we return a resolved promise, in any other case a rejected promise.

Utilizing resolve and reject we are able to talk again a price, within the above case we simply return a string, however it could possibly be an object as effectively.

Consuming a promise

Within the final part, we launched how a promise is created.

Now let’s see how the promise could be consumed or used.

const isItDoneYet = new Promise()
const checkIfItsDone = () => {
.then(okay => {
.catch(err => {

Working checkIfItsDone() will execute the isItDoneYet() promise and can look ahead to it to resolve, utilizing the then callback, and if there may be an error, it would deal with it within the catch callback.

Chaining guarantees

A promise could be returned to a different promise, creating a series of guarantees.

A terrific instance of chaining guarantees is given by the Fetch API, a layer on high of the XMLHttpRequest API, which we are able to use to get a useful resource and queue a series of guarantees to execute when the useful resource is fetched.

The Fetch API is a promise-based mechanism, and calling fetch() is equal to defining our personal promise utilizing new Promise().

Instance of chaining guarantees

const standing = response => {
if (response.standing >= 200 && response.standing < 300) {
return Promise.resolve(response)
return Promise.reject(new Error(response.statusText))
const json = response => response.json()
.then(information => {
console.log('Request succeeded with JSON response', information)
.catch(error => {
console.log('Request failed', error)

On this instance, we name fetch() to get an inventory of TODO objects from the todos.json file discovered within the area root, and we create a series of guarantees.

Working fetch() returns a response, which has many properties, and inside these we reference:

  • standing, a numeric worth representing the HTTP standing code
  • statusText, a standing message, which is OK if the request succeeded

response additionally has a json() methodology, which returns a promise that may resolve with the content material of the physique processed and reworked into JSON.

So given these premises, that is what occurs: the primary promise within the chain is a operate that we outlined, referred to as standing(), that checks the response standing and if it is not successful response (between 200 and 299), it rejects the promise.

This operation will trigger the promise chain to skip all of the chained guarantees listed and can skip on to the catch() assertion on the backside, logging the Request failed textual content together with the error message.

If that succeeds as a substitute, it calls the json() operate we outlined. For the reason that earlier promise, when profitable, returned the response object, we get it as an enter to the second promise.

On this case, we return the information JSON processed, so the third promise receives the JSON immediately:

.then((information) => {
console.log('Request succeeded with JSON response', information)

and we log it to the console.

Dealing with errors

Within the above instance, within the earlier part, we had a catch that was appended to the chain of guarantees.

When something within the chain of guarantees fails and raises an error or rejects the promise, the management goes to the closest catch() assertion down the chain.

new Promise((resolve, reject) => {
throw new Error('Error')
}).catch(err => {
// or
new Promise((resolve, reject) => {
}).catch(err => {

Cascading errors

If contained in the catch() you elevate an error, you’ll be able to append a second catch() to deal with it, and so forth.

new Promise((resolve, reject) => {
throw new Error('Error')
.catch(err => {
throw new Error('Error')
.catch(err => {

Orchestrating guarantees


If that you must synchronize totally different guarantees, Promise.all() helps you outline an inventory of guarantees, and execute one thing when they’re all resolved.


const f1 = fetch('/one thing.json')
const f2 = fetch('/something2.json')
Promise.all([f1, f2])
.then(res => {
console.log('Array of outcomes', res)
.catch(err => {

The ES2015 destructuring project syntax means that you can additionally do

Promise.all([f1, f2]).then(([res1, res2]) => {
console.log('Outcomes', res1, res2)

You aren’t restricted to utilizing fetch in fact, any promise is sweet to go.


Promise.race() runs as quickly as one of many guarantees you go to it resolves, and it runs the hooked up callback simply as soon as with the results of the primary promise resolved.


const promiseOne = new Promise((resolve, reject) => {
setTimeout(resolve, 500, 'one')
const promiseTwo = new Promise((resolve, reject) => {
setTimeout(resolve, 100, 'two')
Promise.race([promiseOne, promiseTwo]).then(outcome => {
console.log(outcome) // 'two'


ES Modules is the ECMAScript normal for working with modules.

Whereas Node.js has been utilizing the CommonJS normal for years, the browser by no means had a module system, as each main determination corresponding to a module system have to be first standardized by ECMAScript after which applied by the browser.

This standardization course of accomplished with ES2015 and browsers began implementing this normal making an attempt to maintain every little thing effectively aligned, working all in the identical manner, and now ES Modules are supported in Chrome, Safari, Edge and Firefox (since model 60).

Modules are very cool, as a result of they allow you to encapsulate all types of performance, and expose this performance to different JavaScript information, as libraries.

The ES Modules Syntax

The syntax to import a module is:

import bundle from 'module-name'

whereas CommonJS makes use of

const bundle = require('module-name')

A module is a JavaScript file that exports a number of values (objects, features or variables), utilizing the export key phrase. For instance, this module exports a operate that returns a string uppercase:


export default str => str.toUpperCase()

On this instance, the module defines a single, default export, so it may be an nameless operate. In any other case it might want a reputation to differentiate it from different exports.

Now, some other JavaScript module can import the performance provided by uppercase.js by importing it.

An HTML web page can add a module through the use of a <script> tag with the particular kind="module" attribute:

<script kind="module" src="http://medium.freecodecamp.org/index.js"></script>

Notice: this module import behaves like a defer script load. See effectively load JavaScript with defer and async

It’s necessary to notice that any script loaded with kind="module" is loaded in strict mode.

On this instance, the uppercase.js module defines a default export, so once we import it, we are able to assign it a reputation we want:

import toUpperCase from './uppercase.js'

and we are able to use it:

toUpperCase('check') //'TEST'

You too can use an absolute path for the module import, to reference modules outlined on one other area:

import toUpperCase from 'https://flavio-es-modules-example.glitch.me/uppercase.js'

That is additionally legitimate import syntax:

import { toUpperCase } from '/uppercase.js'
import { toUpperCase } from '../uppercase.js'

This isn’t:

import { toUpperCase } from 'uppercase.js'
import { toUpperCase } from 'utils/uppercase.js'

It’s both absolute, or has a ./ or / earlier than the identify.

Different import/export choices

We noticed this instance above:

export default str => str.toUpperCase()

This creates one default export. In a file nevertheless you’ll be able to export multiple factor, through the use of this syntax:

const a = 1
const b = 2
const c = 3
export { a, b, c }

One other module can import all these exports utilizing

import * from 'module'

You possibly can import only a few of these exports, utilizing the destructuring project:

import { a } from 'module'
import { a, b } from 'module'

You possibly can rename any import, for comfort, utilizing as:

import { a, b as two } from 'module'

You possibly can import the default export, and any non-default export by identify, like on this widespread React import:

import React, { Part } from 'react'

You possibly can see an ES Modules instance right here: https://glitch.com/edit/#!/flavio-es-modules-example?path=index.html


Modules are fetched utilizing CORS. Which means that in the event you reference scripts from different domains, they should have a sound CORS header that enables cross-site loading (like Entry-Management-Enable-Origin: *)

What about browsers that don’t assist modules?

Use a mix of kind="module" and nomodule:

<script kind="module" src="http://medium.freecodecamp.org/module.js"></script>
<script nomodule src="http://medium.freecodecamp.org/fallback.js"></script>

Wrapping up modules

ES Modules are one of many largest options launched in fashionable browsers. They’re a part of ES6 however the street to implement them has been lengthy.

We are able to now use them! However we should additionally keep in mind that having various modules goes to have a efficiency hit on our pages, because it’s yet one more step that the browser should carry out at runtime.

Webpack might be going to nonetheless be an enormous participant even when ES Modules land within the browser, however having such a function immediately constructed within the language is big for a unification of how modules work client-side and on Node.js as effectively.

New String strategies

Any string worth acquired some new occasion strategies:


Repeats the strings for the desired variety of occasions:

'Ho'.repeat(3) //'HoHoHo'

Returns an empty string if there isn’t a parameter, or the parameter is 0. If the parameter is detrimental you may get a RangeError.


This methodology can be utilized to deal with Unicode characters that can’t be represented by a single 16-bit Unicode unit, however want 2 as a substitute.

Utilizing charCodeAt() that you must retrieve the primary, and the second, and mix them. Utilizing codePointAt() you get the entire character in a single name.

For instance, this Chinese language character “𠮷” consists by 2 UTF-16 (Unicode) elements:

"𠮷".charCodeAt(0).toString(16) //d842
"𠮷".charCodeAt(1).toString(16) //dfb7

In the event you create a brand new character by combining these unicode characters:

"ud842udfb7" //"𠮷"

You will get the identical outcome signal codePointAt():

"𠮷".codePointAt(0) //20bb7

In the event you create a brand new character by combining these unicode characters:

"u{20bb7}" //"𠮷"

Extra on Unicode and dealing with it in my Unicode information.

New Object strategies

ES2015 launched a number of static strategies underneath the Object namespace:

  • Object.is() determines if two values are the identical worth
  • Object.assign() used to shallow copy an object
  • Object.setPrototypeOf units an object prototype


This strategies goals to assist evaluating values.


Object.is(a, b)

The result’s at all times false until:

  • a and b are the identical actual object
  • a and b are equal strings (strings are equal when composed by the identical characters)
  • a and b are equal numbers (numbers are equal when their worth is equal)
  • a and b are each undefined, each null, each NaN, each true or each false

0 and -0 are totally different values in JavaScript, so concentrate on this particular case (convert all to +0 utilizing the + unary operator earlier than evaluating, for instance).


Launched in ES2015, this methodology copies all of the enumerable personal properties of a number of objects into one other.

Its main use case is to create a shallow copy of an object.

const copied = Object.assign({}, unique)

Being a shallow copy, values are cloned, and objects references are copied (not the objects themselves), so in the event you edit an object property within the unique object, that’s modified additionally within the copied object, because the referenced inside object is identical:

const unique = {
identify: 'Fiesta',
automotive: {
shade: 'blue'
const copied = Object.assign({}, unique)
unique.identify = 'Focus'
unique.automotive.shade = 'yellow'
copied.identify //Fiesta
copied.automotive.shade //yellow

I discussed “a number of”:

const wisePerson = {
isWise: true
const foolishPerson = {
isFoolish: true
const wiseAndFoolishPerson = Object.assign({}, wisePerson, foolishPerson)
console.log(wiseAndFoolishPerson) //{ isWise: true, isFoolish: true }


Set the prototype of an object. Accepts two arguments: the article and the prototype.


Object.setPrototypeOf(object, prototype)


const animal = {
isAnimal: true
const mammal = {
isMammal: true
mammal.__proto__ = animal
mammal.isAnimal //true
const canine = Object.create(animal)
canine.isAnimal  //true
console.log(canine.isMammal) //undefined
Object.setPrototypeOf(canine, mammal)
canine.isAnimal //true
canine.isMammal //true

The unfold operator

You possibly can broaden an array, an object or a string utilizing the unfold operator ...

Let’s begin with an array instance. Given

const a = [1, 2, 3]

you’ll be able to create a brand new array utilizing

const b = [...a, 4, 5, 6]

You too can create a replica of an array utilizing

const c = [...a]

This works for objects as effectively. Clone an object with:

const newObj = { ...oldObj }

Utilizing strings, the unfold operator creates an array with every char within the string:

const hey = 'hey'
const arrayized = [...hey] // ['h', 'e', 'y']

This operator has some fairly helpful purposes. Crucial one is the flexibility to make use of an array as operate argument in a quite simple manner:

const f = (foo, bar) => {}
const a = [1, 2]

(Up to now you may do that utilizing f.apply(null, a) however that is not as good and readable.)

The relaxation component is beneficial when working with array destructuring:

const numbers = [1, 2, 3, 4, 5]
[first, second, ...others] = numbers

and unfold parts:

const numbers = [1, 2, 3, 4, 5]
const sum = (a, b, c, d, e) => a + b + c + d + e
const sum = sum(...numbers)

ES2018 introduces relaxation properties, that are the identical however for objects.

Relaxation properties:

const { first, second, ...others } = {
first: 1,
second: 2,
third: 3,
fourth: 4,
fifth: 5
first // 1
second // 2
others // { third: 3, fourth: 4, fifth: 5 }

Unfold properties enable us to create a brand new object by combining the properties of the article handed after the unfold operator:

const objects = { first, second, ...others }
objects //{ first: 1, second: 2, third: 3, fourth: 4, fifth: 5 }


A Set information construction permits us so as to add information to a container.

A Set is a group of objects or primitive varieties (strings, numbers or booleans), and you may consider it as a Map the place values are used as map keys, with the map worth at all times being a boolean true.

Initialize a Set

A Set is initialized by calling:

const s = new Set()

Add objects to a Set

You possibly can add objects to the Set through the use of the add methodology:


A set solely shops distinctive parts, so calling s.add('one') a number of occasions will not add new objects.

You possibly can’t add a number of parts to a set on the identical time. You must name add() a number of occasions.

Test if an merchandise is within the set

As soon as a component is within the set, we are able to verify if the set comprises it:

s.has('one') //true
s.has('three') //false

Delete an merchandise from a Set by key

Use the delete() methodology:


Decide the variety of objects in a Set

Use the dimension property:


Delete all objects from a Set

Use the clear() methodology:


Iterate the objects in a Set

Use the keys() or values() strategies – they’re equal:

for (const ok of s.keys()) {
for (const ok of s.values()) {

The entries() methodology returns an iterator, which you need to use like this:

const i = s.entries()

calling i.subsequent() will return every component as a { worth, achieved = false } object till the iterator ends, at which level achieved is true.

You too can use the forEach() methodology on the set:

s.forEach(v => console.log(v))

or you’ll be able to simply use the set in a for..of loop:

for (const ok of s) {

Initialize a Set with values

You possibly can initialize a Set with a set of values:

const s = new Set([1, 2, 3, 4])

Convert the Set keys into an array

const a = [...s.keys()]
// or
const a = [...s.values()]

A WeakSet

A WeakSet is a particular sort of Set.

In a Set, objects are by no means rubbish collected. A WeakSet as a substitute lets all its objects be freely rubbish collected. Each key of a WeakSet is an object. When the reference to this object is misplaced, the worth could be rubbish collected.

Listed here are the primary variations:

  1. you can not iterate over the WeakSet
  2. you can not clear all objects from a WeakSet
  3. you can not verify its dimension

A WeakSet is usually utilized by framework-level code, and solely exposes these strategies:


A Map information construction permits us to affiliate information to a key.

Earlier than ES6

Earlier than its introduction, folks usually used objects as maps, by associating some object or worth to a particular key worth:

const automotive = {}
automotive['color'] = 'crimson'
automotive.proprietor = 'Flavio'
console.log(automotive['color']) //crimson
console.log(automotive.shade) //crimson
console.log(automotive.proprietor) //Flavio
console.log(automotive['owner']) //Flavio

Enter Map

ES6 launched the Map information construction, offering us a correct device to deal with this type of information group.

A Map is initialized by calling:

const m = new Map()

Add objects to a Map

You possibly can add objects to the map through the use of the set methodology:

m.set('shade', 'crimson')
m.set('age', 2)

Get an merchandise from a map by key

And you may get objects out of a map through the use of get:

const shade = m.get('shade')
const age = m.get('age')

Delete an merchandise from a map by key

Use the delete() methodology:


Delete all objects from a map

Use the clear() methodology:


Test if a map comprises an merchandise by key

Use the has() methodology:

const hasColor = m.has('shade')

Discover the variety of objects in a map

Use the dimension property:

const dimension = m.dimension

Initialize a map with values

You possibly can initialize a map with a set of values:

const m = new Map([['color', 'red'], ['owner', 'Flavio'], ['age', 2]])

Map keys

Similar to any worth (object, array, string, quantity) can be utilized as the worth of the key-value entry of a map merchandise, any worth can be utilized as the important thing, even objects.

In the event you attempt to get a non-existing key utilizing get() out of a map, it would return undefined.

Bizarre conditions you’ll nearly by no means discover in actual life

const m = new Map()
m.set(NaN, 'check')
m.get(NaN) //check
const m = new Map()
m.set(+0, 'check')
m.get(-0) //check

Iterate over map keys

Map presents the keys() methodology we are able to use to iterate on all of the keys:

for (const ok of m.keys()) {

Iterate over map values

The Map object presents the values() methodology we are able to use to iterate on all of the values:

for (const v of m.values()) {

Iterate over map key, worth pairs

The Map object presents the entries() methodology we are able to use to iterate on all of the values:

for (const [k, v] of m.entries()) {
console.log(ok, v)

which could be simplified to

for (const [k, v] of m) {
console.log(ok, v)

Convert the map keys into an array

const a = [...m.keys()]

Convert the map values into an array

const a = [...m.values()]


A WeakMap is a particular sort of map.

In a map object, objects are by no means rubbish collected. A WeakMap as a substitute lets all its objects be freely rubbish collected. Each key of a WeakMap is an object. When the reference to this object is misplaced, the worth could be rubbish collected.

Listed here are the primary variations:

  1. you can not iterate over the keys or values (or key-values) of a WeakMap
  2. you can not clear all objects from a WeakMap
  3. you can not verify its dimension

A WeakMap exposes these strategies, that are equal to the Map ones:

  • get(ok)
  • set(ok, v)
  • has(ok)
  • delete(ok)

The use circumstances of a WeakMap are much less evident than those of a Map, and also you may by no means discover the necessity for them, however basically it may be used to construct a memory-sensitive cache that isn’t going to intervene with rubbish assortment, or for cautious encapsulation and knowledge hiding.


Mills are a particular sort of operate with the flexibility to pause itself, and resume later, permitting different code to run within the meantime.

See the total JavaScript Mills Information for an in depth clarification of the subject.

The code decides that it has to attend, so it lets different code “within the queue” to run, and retains the fitting to renew its operations “when the factor it’s ready for” is finished.

All that is achieved with a single, easy key phrase: yield. When a generator comprises that key phrase, the execution is halted.

A generator can comprise many yield key phrases, thus halting itself a number of occasions, and it is recognized by the *operate key phrase, which isn’t to be confused with the pointer dereference operator utilized in decrease degree programming languages corresponding to C, C++ or Go.

Mills allow complete new paradigms of programming in JavaScript, permitting:

  • 2-way communication whereas a generator is working
  • long-lived whereas loops which don’t freeze your program

Right here is an instance of a generator which explains the way it all works.

operate *calculator(enter) {
var doubleThat = 2 * (yield (enter / 2))
var one other = yield (doubleThat)
return (enter * doubleThat * one other)

We initialize it with

const calc = calculator(10)

Then we begin the iterator on our generator:


This primary iteration begins the iterator. The code returns this object:

achieved: false
worth: 5

What occurs is: the code runs the operate, with enter = 10 because it was handed within the generator constructor. It runs till it reaches the yield, and returns the content material of yield: enter / 2 = 5. So we acquired a price of 5, and the indication that the iteration isn’t achieved (the operate is simply paused).

Within the second iteration we go the worth 7:


and what we acquired again is:

achieved: false
worth: 14

7 was positioned as the worth of doubleThat. Vital: you may learn like enter / 2 was the argument, however that is simply the return worth of the primary iteration. We now skip that, and use the brand new enter worth, 7, and multiply it by 2.

We then attain the second yield, and that returns doubleThat, so the returned worth is 14.

Within the subsequent, and final, iteration, we go in 100


and in return we acquired

achieved: true
worth: 14000

Because the iteration is finished (no extra yield key phrases discovered) and we simply return (enter * doubleThat * one other) which quantities to 10 * 14 * 100.

Supply hyperlink

Leave A Reply

Hey there!

Sign in

Forgot password?

Processing files…