JavaScript ES2026 – najnowsze funkcjonalności języka

Każdego roku komitet TC39, odpowiedzialny za rozwój standardu ECMAScript, zatwierdza nowe propozycje, które trafiają do oficjalnej specyfikacji języka JavaScript. Rok 2026 nie jest wyjątkiem – ES2026 przynosi zestaw bardzo praktycznych i długo oczekiwanych funkcjonalności. W tym artykule omówimy najważniejsze z nich, pokazując konkretne przykłady kodu i wyjaśniając, dlaczego warto już teraz zacząć się z nimi zapoznawać.

1. RegExp.escape() – bezpieczne escapowanie wyrażeń regularnych

Jedną z najbardziej oczekiwanych nowości w ES2026 jest statyczna metoda RegExp.escape(). Do tej pory programiści musieli sami implementować funkcje escapujące ciągi znaków przed użyciem ich w wyrażeniach regularnych, co często prowadziło do błędów i luk bezpieczeństwa.

Nowa metoda automatycznie dodaje znaki ucieczki do wszystkich znaków specjalnych w wyrażeniu regularnym, dzięki czemu możemy bezpiecznie tworzyć dynamiczne wzorce:


// Bez RegExp.escape() - niebezpieczne
const userInput = "cena: 10.50 zł (promocja)";
const regex = new RegExp(userInput); // Błąd! Znaki specjalne nie są escapowane

// Z RegExp.escape() - bezpieczne
const safeInput = RegExp.escape(userInput);
// "cena:\\ 10\\.50\\ zł\\ \\(promocja\\)"
const safeRegex = new RegExp(safeInput);

Jest to szczególnie istotne w aplikacjach, które przyjmują dane od użytkowników i wykorzystują je do budowania wyrażeń regularnych – np. w wyszukiwarkach, filtrach czy walidatorach formularzy.

2. Float16Array – obsługa 16-bitowych liczb zmiennoprzecinkowych

ES2026 wprowadza nowy typ tablicy typizowanej: Float16Array. Liczby 16-bitowe (half-precision float) są szeroko stosowane w grafice komputerowej, uczeniu maszynowym oraz aplikacjach wymagających przetwarzania dużych ilości danych numerycznych przy ograniczonej pamięci.


const float16 = new Float16Array(4);
float16[0] = 1.5;
float16[1] = 3.14;
float16[2] = -0.75;
float16[3] = 100.0;

console.log(float16[0]); // 1.5
console.log(float16[1]); // 3.140625 (przybliżenie w 16-bitach)

Wraz z Float16Array pojawiają się też pomocnicze metody w obiekcie Math: Math.f16round(), która zaokrągla liczbę do najbliższej wartości reprezentowalnej w formacie 16-bitowym – analogicznie do istniejącej już metody Math.fround() dla 32 bitów.


console.log(Math.f16round(3.14159)); // 3.140625
console.log(Math.f16round(0.1));     // 0.099975586

Dla programistów tworzących aplikacje WebGL, WebGPU czy systemy AI działające po stronie klienta, ta funkcjonalność jest prawdziwym przełomem.

3. Iteratory – nowe metody pomocnicze

ES2026 finalizuje i rozszerza zestaw wbudowanych metod na prototypie iteratora (Iterator.prototype). Programiści znający biblioteki takie jak Lodash czy RxJS poczują się jak w domu – nowe metody pozwalają na eleganckie przetwarzanie danych w stylu funkcyjnym bezpośrednio na iteratorach, bez konieczności konwertowania ich do tablic.

Dostępne metody to między innymi:

  • Iterator.prototype.map() – transformacja elementów
  • Iterator.prototype.filter() – filtrowanie elementów
  • Iterator.prototype.take() – pobranie pierwszych N elementów
  • Iterator.prototype.drop() – pominięcie pierwszych N elementów
  • Iterator.prototype.flatMap() – spłaszczanie i transformacja
  • Iterator.prototype.reduce() – agregacja
  • Iterator.prototype.toArray() – konwersja do tablicy
  • Iterator.prototype.forEach() – iteracja z efektem ubocznym
  • Iterator.prototype.some() i Iterator.prototype.every() – testy logiczne
  • Iterator.prototype.find() – wyszukiwanie elementu

// Przykład: przetwarzanie dużego zbioru danych bez tworzenia tablic pośrednich
function* generateNumbers(max) {
  for (let i = 1; i <= max; i++) yield i;
}

const result = generateNumbers(1_000_000)
  .filter(n => n % 2 === 0)
  .map(n => n * n)
  .take(5)
  .toArray();

console.log(result); // [4, 16, 36, 64, 100]

Dzięki temu podejściu unikamy tworzenia ogromnych tablic pośrednich w pamięci – przetwarzanie jest leniwe (lazy), co znacząco poprawia wydajność aplikacji operujących na dużych zbiorach danych.

4. Promise.try() – elegancka obsługa synchronicznych wyjątków

Choć Promise.try() jest koncepcyjnie prostą metodą, rozwiązuje ona irytujący problem, z którym spotykają się programiści na co dzień. Kiedy chcemy opakować w obietnicę funkcję, która może zarówno rzucić wyjątek synchronicznie, jak i zwrócić promise, wcześniej musieliśmy pisać nieelegancki kod:


// Stary sposób - rozwlekły i podatny na błędy
function safeAsync(fn) {
  try {
    return Promise.resolve(fn());
  } catch (error) {
    return Promise.reject(error);
  }
}

// ES2026 - eleganckie rozwiązanie
Promise.try(() => {
  // Może rzucić wyjątek synchronicznie lub zwrócić Promise
  return fetchSomeData();
})
.then(data => console.log(data))
.catch(error => console.error(error));

Promise.try() automatycznie przechwytuje zarówno błędy synchroniczne, jak i asynchroniczne odrzucenia, co sprawia, że obsługa błędów w kodzie asynchronicznym staje się spójna i przewidywalna.

5. Importy modułów z atrybutami (Import Attributes)

ES2026 oficjalnie standardyzuje składnię atrybutów importu (Import Attributes), wcześniej znanych jako Import Assertions. Pozwalają one na przekazywanie metadanych podczas importowania modułów – najbardziej praktyczny przypadek użycia to importowanie plików JSON:


// Importowanie JSON z atrybutem type
import config from "./config.json" with { type: "json" };
import translations from "./i18n/pl.json" with { type: "json" };

console.log(config.apiUrl);
console.log(translations.welcome);

Składnia with { type: "json" } zastępuje wcześniejszą składnię assert { type: "json" }. Zmiana ta wynika z różnicy semantycznej – atrybuty mogą wpływać na sposób interpretacji modułu, podczas gdy poprzednia nazwa sugerowała jedynie walidację.

W przyszłości mechanizm ten będzie można rozszerzyć na inne typy zasobów, jak CSS czy WebAssembly, co otwiera drzwi do jeszcze bardziej elastycznego zarządzania zależnościami w nowoczesnych aplikacjach webowych.

6. Ulepszenia w obsłudze błędów – Error.isError()

Kolejną przydatną nowością jest statyczna metoda Error.isError(), która pozwala bezpiecznie sprawdzić, czy dana wartość jest instancją błędu. W przeciwieństwie do operatora instanceof, metoda ta działa poprawnie również w środowiskach wielokontekstowych (np. między ramkami iframe) i z obiektami przekazywanymi przez granice realm:


// Problematyczne zachowanie instanceof
const err = new Error("test");
// W środowiskach cross-realm instanceof może zwrócić false

// Niezawodna metoda ES2026
console.log(Error.isError(new Error("test")));         // true
console.log(Error.isError(new TypeError("błąd typu"))); // true
console.log(Error.isError({ message: "fake error" }));  // false
console.log(Error.isError("string error"));             // false
console.log(Error.isError(null));                       // false

Jest to szczególnie przydatne w bibliotekach i frameworkach, które muszą niezawodnie obsługiwać błędy niezależnie od kontekstu wykonania.

Jak już teraz korzystać z ES2026?

Część funkcjonalności ES2026 jest już dostępna w najnowszych wersjach przeglądarek i środowisk uruchomieniowych. Oto jak możesz zacząć:

  • Node.js 24+ – zawiera wsparcie dla większości nowych funkcjonalności, w tym Iterator Helpers i Float16Array
  • Google Chrome 127+ i Firefox 131+ – wspierają Iterator Helpers oraz RegExp.escape()
  • Babel – dostępne są pluginy umożliwiające transpilację nowej składni dla starszych środowisk
  • TypeScript 5.5+ – zapewnia typy dla nowych API, takich jak Float16Array i Iterator Helpers

Warto regularnie śledzić repozytorium TC39 na GitHubie, gdzie można obserwować statusy poszczególnych propozycji i planować adopcję nowych funkcjonalności w swoich projektach.

Podsumowanie

ES2026 to solidna aktualizacja standardu JavaScript, która koncentruje się na pragmatycznych potrzebach programistów. RegExp.escape() eliminuje klasę błędów związanych z bezpieczeństwem, Float16Array otwiera nowe możliwości w dziedzinie grafiki i AI, Iterator Helpers rewolucjonizują sposób przetwarzania danych, a Promise.try() upraszcza obsługę asynchroniczności.

Choć żadna z tych funkcji nie jest przełomem na miarę async/await czy klas, łącznie tworzą one spójny zestaw narzędzi, które czynią JavaScript bardziej bezpiecznym, wydajnym i przyjemnym w użyciu. Jeśli tworzysz nowoczesne aplikacje webowe lub backendowe w Node.js – czas zapoznać się z ES2026 i zacząć korzystać z jego dobrodziejstw już dziś.