Write Cleaner, Smarter Code: The Latest JavaScript Features You Must Use

[santoshyada]

JavaScript has been evolving rapidly, introducing powerful new features with each ECMAScript update. These enhancements improve code readability, performance, and developer productivity.

Whether you’re a seasoned JavaScript developer or just getting started, knowing these newest features will help you write cleaner, more efficient, and maintainable code.

Let’s explore the latest game-changing features from ECMAScript 2020 to ECMAScript 2025, along with real-world examples.

ECMAScript 2025 (ES16) Features

1️⃣  Realms API — Secure & Modular JavaScript Execution

JavaScript Realms API allows developers to create isolated global execution contexts. This enhances security and modularity for applications that deal with untrusted code.

💡 Use Case: Securely running third-party scripts inside a separate execution environment.

2️⃣  Standardized Module Attributes — Flexible Module Import

JavaScript modules will now support standardized attributes, improving module interoperability across different environments.

3️⃣  String.prototype.isWellFormed() & toWellFormed()

Ensures strings are properly formatted Unicode sequences.

⚡ ECMAScript 2024 (ES15) Features

1️⃣  Object.groupBy() & Map.groupBy() — Simplified Data Grouping

These methods group objects or data into meaningful categories based on a function.

let data = [
    { type: 'fruit', name: 'apple' },
    { type: 'fruit', name: 'banana' },
    { type: 'vegetable', name: 'carrot' }
];

let grouped = Object.groupBy(data, item => item.type);
console.log(grouped);
// { fruit: [{...}, {...}], vegetable: [{...}] }

💡 Use Case: Grouping user transactions by month, categorizing products in an inventory, etc.

2️⃣  Pipeline Operator (|>) – Function Composition Made Easy

This operator simplifies function chaining and composition, making code more readable.

const double = x => x * 2;
const increment = x => x + 1;

let result = 5 |> double |> increment;
console.log(result); // 11

💡 Use Case: Functional programming patterns become cleaner and more expressive.

3️⃣  New Set Methods — More Power to Sets

New methods like .union(), .intersection(), and .difference() simplify set operations.

let setA = new Set([1, 2, 3]);
let setB = new Set([3, 4, 5]);

console.log(setA.union(setB)); // {1, 2, 3, 4, 5}

💡 Use Case: Easily find common elements between two datasets.

🔍 ECMAScript 2023 (ES14) Features

1️⃣ findLast() & findLastIndex() — Search Arrays Backward

These methods allow searching from the end of an array, making certain operations more efficient.

let numbers = [1, 2, 3, 4, 5, 6];

console.log(numbers.findLast(n => n % 2 === 0)); // 6

💡 Use Case: Finding the most recent matching element in an array.

2️⃣ Immutable Array Methods — Safer Array Manipulation

Methods like .toReversed(), .toSorted(), .toSpliced(), and .with() provide non-mutating alternatives.

let arr = [1, 2, 3];
console.log(arr.toReversed()); // [3, 2, 1]

💡 Use Case: Avoid accidental mutations in large-scale applications.

🔑 ECMAScript 2022 (ES13) Features

1️⃣ Private Class Fields (#) – True Encapsulation

Using # makes fields truly private, unlike _-prefixed convention

class User {
    #password;
    constructor(password) {
        this.#password = password;
    }
}

💡 Use Case: Enforce data privacy inside classes.

2️⃣ at() Method — Cleaner Array Indexing

A better alternative to arr[arr.length - 1] for fetching elements.

let arr = [10, 20, 30];
console.log(arr.at(-1)); // 30

💡 Use Case: Readable and simpler array access.

⚙️ ECMAScript 2021 (ES12) Features

1️⃣ String.prototype.replaceAll() — Global String Replacement

let str = "apple apple apple";
console.log(str.replaceAll("apple", "banana"));

💡 Use Case: Replace all occurrences without regex.

2️⃣ Promise.any() — First Successful Promise Wins

Promise.any([
    Promise.reject("Error"),
    Promise.resolve("Success"),
]).then(console.log); // "Success"

💡 Use Case: Load first available API response from multiple sources.

⚡ ECMAScript 2020 (ES11) Features

1️⃣ Dynamic Import (import()) – Lazy Loading Modules

Improves performance by loading modules only when needed.

import("./module.js").then(module => module.default());

💡 Use Case: Optimize bundle size in large applications.

2️⃣ Nullish Coalescing (??) – Safer Default Values

let value = null ?? "Default";
console.log(value); // "Default"

💡 Use Case: Prevents unintended falsey value replacements like 0 or "".

3️⃣ Optional Chaining (?.) – Prevent Unnecessary Errors

let obj = {};
console.log(obj?.nested?.property); // undefined

💡 Use Case: Avoid TypeError crashes in deeply nested objects.

⚡ ECMAScript 2019 (ES10) Features

1️⃣ Array.prototype.flat() and flatMap() — Flatten nested arrays.

let arr = [1, [2, 3], [4, [5]]];
console.log(arr.flat(2)); // [1, 2, 3, 4, 5]

💡 Use Case: Simplifies working with deeply nested arrays.

2️⃣ Object.fromEntries() — Converts key-value pairs into an object.

let entries = [['a', 1], ['b', 2]];
console.log(Object.fromEntries(entries)); // { a: 1, b: 2 }

💡 Use Case: Useful for converting Map objects back to plain objects.

⚡ ECMAScript 2018 (ES9) Features

1️⃣ Rest/Spread Properties for Objects — Simplifies copying and merging objects.

let obj = { a: 1, b: 2, c: 3 };
let { a, ...rest } = obj;
console.log(rest); // { b: 2, c: 3 }

💡 Use Case: Reduces the need for manual object cloning.

2️⃣ Promise.prototype.finally() — Executes code after promise completion.

fetch('/api/data')
    .then(response => response.json())
    .catch(error => console.error(error))
    .finally(() => console.log('Request completed'));

💡 Use Case: Ensures cleanup tasks are always executed.

⚡ ECMAScript 2017 (ES8) Features

1️⃣ Async/Await — Enables writing asynchronous code in a synchronous style.

async function fetchData() {
    let response = await fetch('https://api.example.com');
    let data = await response.json();
    console.log(data);
}

💡 Use Case: Improves readability of asynchronous code.

2️⃣ Object.entries() and Object.values() — Allows iterating over object properties.

let obj = { a: 1, b: 2 };
console.log(Object.entries(obj)); // [['a', 1], ['b', 2]]
console.log(Object.values(obj)); // [1, 2]

💡 Use Case: Simplifies working with object properties.

⚡ ECMAScript 2016 (ES7) Features

1️⃣ Array.prototype.includes() — Checks if an array contains a specific value.

let arr = [1, 2, 3];
console.log(arr.includes(2)); // true

💡 Use Case: More readable alternative to indexOf().

2️⃣ Exponentiation Operator (**) – Provides a shorthand for exponentiation.

console.log(2 ** 3); // 8

💡 Use Case: Simplifies mathematical calculations.

⚡ ECMAScript 2015 (ES6) Features

1️⃣ Let and Const — Block-scoped variable declarations.

let x = 10;
const y = 20;

💡 Use Case: Prevent accidental variable reassignments.

2️⃣ Arrow Functions — Shorter syntax for functions.

const add = (a, b) => a + b;

💡 Use Case: More concise function expressions.

3️⃣ Template Literals — Embed expressions within strings.

let name = "John";
console.log(`Hello, ${name}!`);

💡 Use Case: Improves readability when constructing strings.

4️⃣ Default Parameters — Assign default values to function parameters.

function greet(name = "Guest") {
    console.log(`Hello, ${name}!`);
}

💡 Use Case: Avoids undefined function arguments.

5️⃣ Destructuring Assignment — Extract values from arrays and objects easily.

let [a, b] = [1, 2];
let { name, age } = { name: "John", age: 30 };

💡 Use Case: Simplifies data extraction.

6️⃣ Promises — Improved handling of asynchronous operations.

let fetchData = () => new Promise(resolve => setTimeout(() => resolve("Data loaded"), 1000));
fetchData().then(data => console.log(data));

💡 Use Case: Enhances readability of async code.

7️⃣ Modules (import/export) — Enable modular JavaScript.

import { myFunction } from "./module.js";

💡 Use Case: Organizes and reuses code efficiently.

🎯 Conclusion

JavaScript continues to evolve with each new ECMAScript version, introducing features that enhance performance, readability, and maintainability. While the ServiceNow platform does not support features beyond ES2021, we can leverage all features up to and including ES2021 to write efficient and modern code.