ES2020 Features in simple examples
Tags: javascript, webdev, node, es2020
Published: 2020-01-03 08:14:05

---
title: ES2020 Features in simple examples
published: true
description: ES2020 is the version of ECMAScript corresponding to the year 2020. This version does not include as many new features as those that appeared in ES6 (2015). However, some useful features have been incorporated.
tags: javascript, webdev, node, ES2020
series: understanding-javascript
cover_image: https://cdn-images-1.medium.com/max/8000/1*HRBqZ6UDItqS7nNwug0HvQ.jpeg
canonical_url: https://carloscaballero.io/es2020-features-in-simple-examples
---

In this series, we are going to show the EcmaScript features from 2015 to today.

* ES2015 aka ES6

* ES2016 aka ES7

* ES2017 aka ES8

* ES2018 aka ES9

* [ES2019 aka ES10](https://dev.to/carlillo/12-es10-features-in-12-simple-examples-2cbn)

* [ES2020 aka ES11](https://carloscaballero.io/es2020-features-in-simple-examples)

---

## Introduction

ES2020 is the version of ECMAScript corresponding to the year 2020. This version does not include as many new features as those that appeared in ES6 (2015). However, some useful features have been incorporated.

This article introduces the features provided by ES2020 in easy code examples. In this way, you can quickly understand the new features without the need for a complex explanation.

Of course, it is necessary to have a basic knowledge of JavaScript to fully understand the best ones introduced.

The new **#JavaScript** features in **ES2020** are:

➡️ String.prototype.matchAll
➡️ import()
➡️ BigInt
➡️ Promise.allSettled
➡️ globalThis
➡️ for-in mechanics
➡️ Optional Chaining
➡️ Nullish coalescing Operator

## String.protype.matchAll

The matchAll() method returns an iterator of all results matching a string against a regular expression, including capturing groups.

![](https://cdn-images-1.medium.com/max/4000/0*1m79UsEsrZ4r6WbZ.png)

## Dynamic import

Dynamic import() returns a promise for the module namespace object of the requested module. Therefore, imports can now be assigned to a variable using async/await.

![](https://cdn-images-1.medium.com/max/2184/0*ctjC9soy9w5T6bvz.png)

## BigInt — Arbitrary precision integers

BigInt is the 7th primitive type and It is an arbitrary-precision integer. The variables can now represent ²⁵³ numbers and not just max out at 9007199254740992.

![](https://cdn-images-1.medium.com/max/2792/0*onvFb9K4FoJEQI8L.png)

## Promise.allSettled

Promise.allSettled returns a promise that is fulfilled with an array of promise state snapshots, but only after all the original promises have settled, i.e. become either fulfilled or rejected.

We say that a promise is settled if it is not pending, i.e. if it is either fulfilled or rejected.

![](https://cdn-images-1.medium.com/max/2828/0*iwlDqeH4nJft4bBO.png)

## Standardized globalThis object

The global this was not standardized before ES10.
In production code you would “standardize” it across multiple platforms on your own by writing this monstrosity:

![](https://cdn-images-1.medium.com/max/4000/0*_5WJeNyD92zaSkj4.png)

## for-in mechanics

ECMA-262 leaves the order of for (a in b)... almost totally unspecified, but real engines tend to be consistent in at least some cases.

Historical efforts to get consensus on a complete specification of the order of for-in have repeatedly failed, in part because all engines have their own idiosyncratic implementations which are the result of a great deal of work and which they don’t really want to revisit.

In conclusion, the different engines have agreed on how properties are iterated when using the for (a in b) control structure so that the behavior is standardized.

## Nullish coalescing Operator

When performing property accesses, it is often desired to provide a default value if the result of that property access is **null** or **undefined**. At present, a typical way to express this intent in JavaScript is by using the || operator.

![](https://cdn-images-1.medium.com/max/3772/0*QmmD9FX-IlVhrxSx.png)

This works well for the common case of null and undefined values, but there are a number of falsy values that might produce surprising results.

The nullary **coalescing operator** is intended to handle these cases better and serves as an equality check against nullary values (**null or undefined**). If the expression at the left-hand side of the ?? operator evaluates to **undefined or null**, its right-hand side is returned.

![](https://cdn-images-1.medium.com/max/3432/0*7ec8CW7rvYSjCqBs.png)

## Optional Chaining

When looking for a property value that’s deep in a tree-like structure, one often has to check whether intermediate nodes exist.

The **Optional Chaining Operator** allows handle many of those cases without repeating themselves and/or assigning intermediate results in temporary variables.

![](https://cdn-images-1.medium.com/max/4000/0*alRDfnMCiso9WSWa.png)

Also, many API return either an object or null/undefined, and one may want to extract a property from the result only when it is not null:

![](https://cdn-images-1.medium.com/max/3228/0*_YzdDQCPlmFqk9G8.png)

When some other value than *undefined* is desired for the missing case, this can usually be handled with the **Nullish coalescing** operator:

![](https://cdn-images-1.medium.com/max/4000/0*b_ex0BMSmzl1qSTS.png)

## Conclusion

JavaScript is a live language, and that is something very healthy for web development. Since the appearance of ES6 in 2015 we are living a vibrant evolution in the language. In this post we have reviewed the features that arise in **ES2020**.

Although many of these features may not be essential for the development of your Web application, they are giving possibilities that could be achieved before with tricks or a lot of verbosity.