ECMAScript 2026

New Features in JavaScript 2026

ECMAScript 2026 (ES2026), the 17th edition of the JavaScript language specification, was officially ratified by ECMA International on June 30, 2026.

• Accurate Math with Math.sumPrecise()
• Error detection with Error.isError()
• Asynchronous array creation with Array.fromAsync()
• Map upsert with getOrInsert()
• High-precision JSON with rawJSON()
• Base64 and hexadecimal encodings for Uint8Array

Features Pushed to ES2027

While highly visible in the ecosystem through mature polyfills, a couple of major proposals just missed the June 2026 cutoff for official inclusion and are officially slated for next year's spec:

• Temporal API

The long-time-overdue successor to the buggy, 30-year-old Date object. Unlike Date, Temporal objects are immutable and provide first-class support for time zones and non-Gregorian calendars.

• Explicit Resource Management (using keyword)

C#-style block-scoped disposal variables that auto-clean up database connections and streams when leaving context, avoiding try...finally boilerplate.

Accurate Math with Math.sumPrecise()

Math.sumPrecise() fixes the classic 0.1 + 0.2 === 0.30000000000000004 floating-point problem when summing lists of numbers.

Computers do not think in base-10 decimals like humans; they think in binary bits, which causes structural math flaws in programming.

The Problem: In JavaScript, 0.1 + 0.2 has historically equaled 0.30000000000000004 due to floating-point rounding errors. This is dangerous for financial apps.

The Fix: Math.sumPrecise changes how the underlying language engine calculates a list of decimals, bypassing the system's structural limitation to deliver a perfect sum.

Map Upsert with getOrInsert()

Map.prototype.getOrInsert removes the boilerplate of checking if a key exists before adding an item to a Map structure.

A data structure (like an Array or a Map) holds your information. Previously, JavaScript's built-in structures lacked common-sense shortcuts found in other languages.

The Problem: If you wanted to update a dictionary (Map), you had to write an if statement to check if the key existed, create it if missing, and then update it.

The Fix: Map.prototype.getOrInsert lets you find or create data in one quick move. It expands what the data structure can do natively.

Example

const userRoles = new Map();

// Old Way: Multi-line checks

if (!userRoles.has("admin")) {

  userRoles.set("admin", []);

}

userRoles.get("admin").push("Alice");

// New ES2026 Way: Single-line default insertion

userRoles.getOrInsert("admin", []).push("Bob");

userRoles.getOrInsert("admin", []).push("Charlie");

console.log(userRoles.get("admin")); // ['Bob', 'Charlie']

High-Precision JSON with rawJSON()

JSON.rawJSON preserves large numbers (like ID strings from databases) without losing digits due to internal rounding.

Example

const precisionLossJSON = '{"id": 9223372036854775807}';

// New ES2026 Reviver: Accesses the raw source string before rounding

const data = JSON.parse(precisionLossJSON, (key, value, context) => {

  if (key === 'id') {

    return context.source; // "9223372036854775807" as a string

  }

  return value;

});

// New ES2026 Stringify: Outputs the unrounded big integer safely

const output = JSON.stringify({

  id: JSON.rawJSON("9223372036854775807")

});

Error.isError()

Error.isError() is a static method to reliably check if a value is an Error object, improving error handling and debugging.

Error.isError() reliably detects error objects even if they originated from inside an <iframe> or a separate runtime sandbox.

Example

Error.isError(new TypeError());   // true

Error.isError({ name: "Error" }); // false

Realm-safe error check: An Error from an iframe verifies with Error.isError() and fails with instanceof.

Example

Error.isError() is a safe alternative to instanceof Error which fails across realms.

try {

  throw new TypeError("Invalid format");

} catch (err) {

  // Old Way: Could fail across different window contexts

  console.log(err instanceof Error);

  // New ES2026 Way: Globally reliable

  console.log(Error.isError(err)); // true

}

Browser Support

Error.isError() is already supported in many browsers:

Array.fromAsync()

Array.fromAsync() is a feature that allows developers to create a new Array instance from asynchronous iterables, array-like objects, or Promises, streamlining the handling of data from async sources.

Example

// An async generator simulating a paginated API

async function* fetchPages() {

  yield;

  yield;

}

// New ES2026 Way: Resolves and flattens natively

const allData = await Array.fromAsync(fetchPages(), flatMap => flatMap);

console.log(allData); // [1, 2, 3, 4]

Example

async function* asyncGenerator() {

  yield Promise.resolve(1);

  yield Promise.resolve(2);

  yield Promise.resolve(3);

}

async function processAsyncData() {

  const arr = await Array.fromAsync(asyncGenerator());

}

processAsyncData();

Browser Support

Array.fromAsync() is supported in all major browsers:

New Uint8Array Methods

Base64 and Hexadecimal Encodings for Uint8Array.

These new static methods facilitate working with binary data by adding direct conversion between Uint8Array objects and Base64 or hexadecimal strings.

This eliminates the need for external buffer modules or hacky window methods like btoa() and atob().

• Uint8Array fromBase64()

• Creates a Uint8Array object from a base64-encoded string Uint8Array toBase64()

• Returns a base64-encoded string from the data in an int8Array Uint8Array fromHex()

• Creates a Uint8Array object from a hexadecimal string Uint8Array toHex()

• Returns a hex-encoded string from the data in an int8Array

Uint8Array to/fromBase64()

Examples

// Creating raw binary data

const bytes = new Uint8Array([72, 101, 108, 108, 111]); // "Hello"

// New ES2026: Direct string conversions

const base64String = bytes.toBase64();

console.log(base64String); // "SGVsbG8="

const hexString = bytes.toHex();

console.log(hexString); // "48656c6c6f"

// Reversing the operation

const restoredBytes = Uint8Array.fromBase64("SGVsbG8=");

let string = 'Example 123';

const arr = Uint8Array.fromBase64(string);

const arr = new Uint8Array([91,116,156,134,138,37,179,93,183]);

let text = arr.toBase64();

Browser Support

to/fromBase64() is supported in all major browsers:

Uint8Array to/fromHex()

Examples

let text = '5b749c868a25b35db7';

const arr = Uint8Array.fromHex(text);

const arr = new Uint8Array([91,116,156,134,138,37,179,93,183]);

let text = arr.toHex();

Browser Support

to/fromHex() is supported in all major browsers:

Accurate Floating-Point Math

The Math.sumPrecise() Method fixes the classic 0.1 + 0.2 === 0.30000000000000004 floating-point problem when summing lists of numbers.

Example

// Old Way: Inaccuracies accumulate

const items = [0.1, 0.2, 0.3];

const badSum = items.reduce((a, b) => a + b, 0);

myDisplayer(badSum);

// New ES2026 Way: Perfectly precise

const preciseSum = Math.sumPrecise(items);

myDisplayer(preciseSum);

Browser Support

Math.sumPrecise() is supported in all major browsers:

Free account

Contact Sales

If you want to use Example services as an educational institution, team or enterprise, send us an e-mail:

Report Error

If you want to report an error, or if you want to make a suggestion, send us an e-mail: [email protected]

Top Tutorials

HTML Tutorial CSS Tutorial JavaScript Tutorial How To Tutorial SQL Tutorial Python Tutorial Bootstrap Tutorial PHP Tutorial Java Tutorial C++ Tutorial jQuery Tutorial

Top References

HTML Reference CSS Reference JavaScript Reference SQL Reference Python Reference Bootstrap Reference PHP Reference HTML Colors Java Reference AngularJS Reference jQuery Reference

Top Examples

HTML Examples CSS Examples JavaScript Examples How To Examples SQL Examples Python Examples Bootstrap Examples PHP Examples Java Examples XML Examples jQuery Examples