Here are Some New Features in JavaScript

JavaScript code on a modern developer

ECMAScript 2023 (ES14)

JavaScript continues to evolve with the ECMAScript 2023 (ES14) update, bringing several exciting features that enhance the language’s capabilities and simplify coding practices. Let’s dive into the new array methods, hashbang grammar, and RegExp match indices to understand their benefits and practical applications.

Array Methods

The ES14 update introduces two powerful array methods: Array.prototype.findLast and Array.prototype.findLastIndex. These methods are similar to find and findIndex, but they search the array from the end instead of the beginning, making it easier to locate elements in reverse order.

Example: findLast and findLastIndex

const numbers = [5, 12, 8, 130, 44];
const lastLargeNumber = numbers.findLast(num => num > 10);
console.log(lastLargeNumber); // Output: 130

const lastLargeNumberIndex = numbers.findLastIndex(num => num > 10);
console.log(lastLargeNumberIndex); // Output: 3

These methods are particularly useful when you need to find the most recent occurrence of an element in an array, improving code readability and efficiency.

Hashbang Grammar

Hashbangs, or shebangs, are a useful feature borrowed from scripting languages. In ES14, you can now include a hashbang at the start of a JavaScript file to specify the interpreter path, making your scripts more portable across different environments.

Example: Hashbang in JavaScript

#!/usr/bin/env node
console.log('This script runs with Node.js');

When you run this script in a Unix-like environment, the system uses the specified interpreter (/usr/bin/env node) to execute the script. This addition aligns JavaScript with other scripting languages and enhances script portability.

RegExp Match Indices

Regular expressions in JavaScript become even more powerful with the introduction of the d flag, which provides match indices. This feature allows you to capture the start and end positions of matches, enabling more precise text processing and manipulation.

Example: RegExp Match Indices

const regex = /a(b)c/gd;
const str = 'abc abc abc';
const match = regex.exec(str);

console.log(match.indices); // Output: [[0, 3], [1, 2]]

With match indices, you gain additional control over text processing tasks, making regular expressions more versatile and useful for complex string manipulation scenarios.

Temporal API: Improved Date and Time Handling

The Temporal API, a significant addition to JavaScript, addresses long-standing issues with the Date object, providing a modern and comprehensive solution for date and time manipulation. It offers more precise and user-friendly ways to handle dates and times, making it an essential tool for developers.

Introduction to Temporal API

The Temporal API was introduced to overcome the limitations and complexities of the traditional Date object. It offers a new set of objects and methods that simplify the handling of date and time, ensuring accuracy and ease of use across various time zones and calendars.

Key Features of Temporal API

  1. Immutable Objects: Temporal objects are immutable, meaning once created, they cannot be changed. This ensures consistency and prevents unintentional modifications.
  2. Time Zone Awareness: The Temporal API handles time zones more effectively, allowing precise calculations and conversions.
  3. Human-Friendly Parsing and Formatting: Temporal simplifies parsing and formatting dates, reducing the potential for errors.

Creating Temporal Objects

Temporal provides various objects to handle different aspects of date and time:

  • Temporal.PlainDate: Represents a date without a time or time zone.
  • Temporal.PlainTime: Represents a time without a date or time zone.
  • Temporal.PlainDateTime: Represents a date and time without a time zone.
  • Temporal.ZonedDateTime: Represents a date and time with a time zone.

Example: Creating Temporal Objects

const plainDate = Temporal.PlainDate.from('2023-05-23');
console.log(plainDate.toString()); // Output: 2023-05-23

const plainTime = Temporal.PlainTime.from('14:35:10');
console.log(plainTime.toString()); // Output: 14:35:10

const plainDateTime = Temporal.PlainDateTime.from('2023-05-23T14:35:10');
console.log(plainDateTime.toString()); // Output: 2023-05-23T14:35:10

const zonedDateTime = Temporal.ZonedDateTime.from('2023-05-23T14:35:10+01:00[Europe/London]');
console.log(zonedDateTime.toString()); // Output: 2023-05-23T14:35:10+01:00[Europe/London]

Performing Date Arithmetic

Temporal makes date arithmetic straightforward and reliable, handling complexities like leap years and daylight saving changes effortlessly.

Example: Adding and Subtracting Dates

const initialDate = Temporal.PlainDate.from('2023-05-23');
const nextWeek = initialDate.add({ days: 7 });
console.log(nextWeek.toString()); // Output: 2023-05-30

const previousMonth = initialDate.subtract({ months: 1 });
console.log(previousMonth.toString()); // Output: 2023-04-23

Handling Time Zones

Temporal’s handling of time zones ensures accurate date and time calculations across different regions.

Example: Working with Time Zones

const zonedDateTime = Temporal.ZonedDateTime.from('2023-05-23T14:35:10+01:00[Europe/London]');
const utcDateTime = zonedDateTime.withTimeZone('UTC');
console.log(utcDateTime.toString()); // Output: 2023-05-23T13:35:10Z

Parsing and Formatting Dates

Temporal simplifies parsing and formatting dates, making it easier to work with different date representations.

Example: Parsing and Formatting

const dateStr = '23 May 2023';
const parsedDate = Temporal.PlainDate.from(dateStr);
console.log(parsedDate.toString()); // Output: 2023-05-23

const formattedDate = parsedDate.toLocaleString('en-US', { month: 'long', day: 'numeric', year: 'numeric' });
console.log(formattedDate); // Output: May 23, 2023

Top-Level Await: Asynchronous Operations in Modules

JavaScript has taken a significant step forward with the introduction of top-level await, simplifying asynchronous operations in modules. This feature allows developers to use the await keyword at the top level of a module, enabling cleaner and more intuitive code for handling asynchronous tasks.

Understanding Top-Level Await

Traditionally, the await keyword could only be used inside asynchronous functions. This often led to extra boilerplate code, especially when dealing with module-level asynchronous operations. Top-level await eliminates this restriction, allowing await to be used directly within modules.

Benefits of Top-Level Await

  1. Simplified Code: Reduces the need for wrapping code in async functions, making the code more readable and straightforward.
  2. Improved Initialization: Enables asynchronous module initialization, allowing modules to await necessary data before fully exporting.
  3. Better Error Handling: Allows for more consistent and manageable error handling at the module level.

Practical Examples

Let’s explore some common use cases where top-level await can simplify your code.

Example: Fetching Data from an API

Without top-level await, you need to wrap the asynchronous code in an async function:

async function fetchData() {
  const response = await fetch('');
  const data = await response.json();


With top-level await, the same task becomes more straightforward:

const response = await fetch('');
const data = await response.json();

Example: Module Initialization

Consider a module that needs to load configuration data asynchronously before exporting functionality:

// config.js
const configResponse = await fetch('/config.json');
const config = await configResponse.json();

export default config;

In this example, the module exports the configuration object only after it has been fully loaded and parsed, ensuring that any importing module receives the correct data.

Handling Errors

Top-level await allows for more seamless error handling directly at the module level:

try {
  const response = await fetch('');
  if (!response.ok) {
    throw new Error('Network response was not ok');
  const data = await response.json();
} catch (error) {
  console.error('Failed to fetch data:', error);

This approach ensures that errors are caught and handled where they occur, providing clearer and more maintainable code.

WeakRefs and FinalizationRegistry: Memory Management Enhancements

JavaScript’s memory management capabilities have been significantly enhanced with the introduction of WeakRefs and FinalizationRegistry. These features provide developers with advanced tools to manage memory more effectively, ensuring that applications run smoothly without unnecessary memory leaks or performance degradation.

Understanding WeakRefs

WeakRefs, or Weak References, allow you to hold a weak reference to an object, meaning the referenced object can be garbage collected if there are no other strong references to it. This is particularly useful for caching and managing memory in large applications where you need to keep references to objects without preventing their garbage collection.

Example: Using WeakRefs

let cache = new WeakMap();

function getUser(id) {
  if (!cache.has(id)) {
    let user = fetchUserFromDatabase(id); // Assume this is a function fetching user data
    cache.set(id, user);
  return cache.get(id);

In this example, the cache holds a weak reference to user objects. If the user object is no longer needed and there are no strong references to it, the garbage collector can reclaim the memory.

Understanding FinalizationRegistry

The FinalizationRegistry API allows you to register a callback that gets called when an object is garbage collected. This is useful for cleaning up resources or performing actions when objects are no longer in use.

Example: Using FinalizationRegistry

const registry = new FinalizationRegistry((heldValue) => {
  console.log(`Object with value ${heldValue} has been garbage collected`);

let obj = {};
registry.register(obj, 'some value');

// Dereference the object
obj = null;

// When the garbage collector runs, the callback will be invoked

Here, the registry registers an object and a held value. When the object is garbage collected, the callback logs a message. This helps in managing resources like file handles or network connections that need explicit cleanup.

Practical Applications

Caching: WeakRefs are ideal for caching mechanisms where you want to keep objects in memory as long as they are needed but allow garbage collection when they are not.

let userCache = new WeakMap();

function cacheUser(user) {
  userCache.set(, user);

function getUserFromCache(id) {
  return userCache.get(id);

Resource Management: FinalizationRegistry can help manage resources by performing cleanup actions when objects are no longer referenced.

class FileManager {
  constructor(file) {
    this.file = file;
    this.cleanup = new FinalizationRegistry((file) => {
      console.log(`File ${} has been closed`);
    this.cleanup.register(this, this.file);

let manager = new FileManager(openFile('example.txt'));
manager = null; // Dereference manager, allowing the file to be closed when garbage collected

Reach out if you want to join me and write articles with the nerds 🙂

© 2024 · Nerd Level Tech


Social Media

Stay connected on social media