Exploring the Exciting Features of ECMAScript 2020: A Leap Forward for JavaScript

ECMAScript, the standardized specification of JavaScript, evolves continuously to bring new features and enhancements to the language. In 2020, ECMAScript 2020 (ES2020) introduced several exciting features that further empower JavaScript developers. In this article, we will dive into some of these notable features, exploring their capabilities and showcasing how they can elevate your JavaScript programming to new heights.

BigInt: JavaScript has always struggled with precise numeric representations for extremely large integers. The BigInt feature in ES2020 addresses this limitation. BigInts are arbitrary-precision integers, allowing you to perform accurate calculations with massive numbers.

const largeNumber = BigInt("9007199254740991234567890");
const result = largeNumber * 2n;
console.log(result); // Output: 18014398509481982469135780n

Optional Chaining (?.): Optional chaining is a powerful feature that simplifies property access when dealing with nested objects or uncertain data structures. It allows you to safely access nested properties without throwing errors if intermediate properties are nullish or undefined.

const user = {
  name: "John",
  address: {
    street: "123 Main St",
    city: "New York",
  },
};

const zipCode = user.address?.zipCode;
console.log(zipCode); // Output: undefined

Nullish Coalescing Operator (??): The nullish coalescing operator provides a concise way to select a default value when a variable is null or undefined. It differs from the logical OR operator (||) as it only checks for nullish values (null or undefined), ensuring accurate default value assignments.

const name = null;
const displayName = name ?? "Guest";
console.log(displayName); // Output: "Guest"

Promise.allSettled(): The Promise.allSettled() method returns a promise that resolves after all the given promises have settled, whether they were fulfilled or rejected. It allows you to handle multiple promises concurrently and obtain their final statuses.

const promises = [
  fetch(url1),
  fetch(url2),
  fetch(url3),
];

Promise.allSettled(promises)
  .then(results => {
    results.forEach((result, index) => {
      if (result.status === "fulfilled") {
        console.log(`Promise ${index + 1} resolved:`, result.value);
      } else {
        console.log(`Promise ${index + 1} rejected:`, result.reason);
      }
    });
  });

String.prototype.matchAll(): The matchAll() method returns an iterator of all matches for a specified regular expression within a string. It allows you to iterate over multiple matches and extract useful information from them.

const regex = /#[a-zA-Z]+/g;
const text = "Hello #world, #JavaScript is #awesome!";
const matches = [...text.matchAll(regex)];

matches.forEach(match => {
  console.log(match[0]); // Output: "#world", "#JavaScript", "#awesome"
});

ECMAScript 2020 brought forth a collection of powerful features that enhance JavaScript’s capabilities, empowering developers to write cleaner, more efficient, and expressive code. The introduction of BigInts, optional chaining, nullish coalescing operator, Promise.allSettled(), and String.prototype.matchAll() has revolutionized how we handle large numbers, deal with nested objects, handle default values, work with promises, and perform advanced string matching.

Get N’s stories in your inbox

Join Medium for free to get updates from this writer.

Remember me for faster sign in

By leveraging these ES2020 features, you can unlock new possibilities in your JavaScript projects, improve code quality, and enhance your development workflow. Stay updated with the latest ECMAScript specifications to ensure you’re utilizing the full potential of JavaScript.

So, embrace the advancements of ECMAScript 2020 and elevate your JavaScript programming to new heights of productivity and creativity.