Kurs JavaScript i TypeScript · Moduł 5: Zaawansowany JavaScript

ES2024 i ES2025 - Najnowsze funkcje JavaScript

8 min czytania ·
W tej lekcji5

Dr. Henry Wu właśnie wrócił z konferencji programistów. "JavaScript ciągle ewoluuje," mówi. "Najnowsze wersje ECMAScript przynoszą funkcje, które znacznie uproszczą nasz kod!" Do tej pory grupowanie wymagało reduce() i pustego obiektu, a posortowanie listy bez niszczenia oryginału - ręcznej kopii. Nowe wersje standardu zamieniają takie łatki w jedną linijkę.

Jak ewoluuje ECMAScript

Nad językiem pracuje komitet TC39, a od 2015 roku nowa wersja standardu ukazuje się co roku i nosi nazwę od roku wydania. Propozycja przechodzi kolejne etapy i trafia do standardu po osiągnięciu etapu 4, który wymaga między innymi działających implementacji. Kamienie milowe tej ewolucji:

  • ES6 (ES2015) - let i const, funkcje strzałkowe, destrukturyzacja
  • ES2017 - async i await
  • ES2020 - optional chaining (?.) i nullish coalescing (??)
  • ES2023 - metody tablic bez mutacji, np. toSorted()
  • ES2024 - Object.groupBy() i Promise.withResolvers()
  • ES2025 - nowe metody Set, Promise.try() i import JSON

ES2024 - Najważniejsze nowości

1. Object.groupBy() i Map.groupBy()

Grupowanie elementów tablicy według klucza - bez bibliotek zewnętrznych! Podajesz tablicę i funkcję, która dla każdego dinozaura zwraca nazwę jego grupy:

const dinosaurs = [
  { name: 'Rex', type: 'carnivore', sector: 7 },
  { name: 'Blue', type: 'carnivore', sector: 3 },
  { name: 'Sarah', type: 'herbivore', sector: 5 },
  { name: 'Bronty', type: 'herbivore', sector: 5 },
  { name: 'Delta', type: 'carnivore', sector: 3 }
];

// Grupowanie po typie
const byType = Object.groupBy(dinosaurs, dino => dino.type);
console.log(byType);
// {
//   carnivore: [{ name: 'Rex', ... }, { name: 'Blue', ... }, { name: 'Delta', ... }],
//   herbivore: [{ name: 'Sarah', ... }, { name: 'Bronty', ... }]
// }

// Grupowanie po sektorze
const bySector = Object.groupBy(dinosaurs, dino => `Sector-${dino.sector}`);
console.log(bySector);

// Map.groupBy - gdy potrzebujesz Map zamiast obiektu
const byTypeMap = Map.groupBy(dinosaurs, dino => dino.type);
console.log(byTypeMap.get('carnivore'));

Każdy klucz wyniku prowadzi do tablicy pasujących dinozaurów - to samo budowaliśmy wcześniej przez reduce(). Obiekt z Object.groupBy() nie ma prototypu, więc nie odziedziczy metod w rodzaju hasOwnProperty(). Map.groupBy() wybierz, gdy kluczami mają być obiekty, a nie napisy.

2. Metody tablicowe bez mutacji (ES2023)

Formalnie te metody weszły do standardu rok wcześniej, w ES2023, ale wciąż należą do najświeższych narzędzi. Zwracają nową tablicę zamiast modyfikować oryginalną:

const sectors = ['Sector-1', 'Sector-7', 'Sector-3', 'Sector-5'];

// Stare metody MUTUJĄ oryginalną tablicę
const oldWay = [...sectors];
oldWay.sort(); // Zmienia oldWay!

// toSorted() - sortuje bez mutacji
const sorted = sectors.toSorted();
console.log(sorted);   // ['Sector-1', 'Sector-3', 'Sector-5', 'Sector-7']
console.log(sectors);  // ['Sector-1', 'Sector-7', 'Sector-3', 'Sector-5'] - niezmienione!

// toReversed() - odwraca bez mutacji
const reversed = sectors.toReversed();
console.log(reversed); // ['Sector-5', 'Sector-3', 'Sector-7', 'Sector-1']
console.log(sectors);  // Nadal oryginalne!

// toSpliced() - splice bez mutacji
const withNew = sectors.toSpliced(1, 1, 'Sector-9', 'Sector-10');
console.log(withNew);  // ['Sector-1', 'Sector-9', 'Sector-10', 'Sector-3', 'Sector-5']

// with() - zamień element bez mutacji
const updated = sectors.with(1, 'Sector-ALPHA');
console.log(updated);  // ['Sector-1', 'Sector-ALPHA', 'Sector-3', 'Sector-5']

// Praktyczny przykład: sortowanie dinozaurów
const dinoList = [
  { name: 'Rex', dangerLevel: 10 },
  { name: 'Blue', dangerLevel: 8 },
  { name: 'Sarah', dangerLevel: 3 }
];

// Sortuj po poziomie zagrożenia (malejąco) bez mutacji
const byDanger = dinoList.toSorted((a, b) => b.dangerLevel - a.dangerLevel);
console.log(byDanger[0].name); // 'Rex'

Każda nowa metoda ma mutującą starszą siostrę: toSorted() to sort(), toReversed() to reverse(), a toSpliced() to splice(). with(index, value) zastępuje przypisanie po indeksie i rzuca RangeError dla indeksu spoza tablicy. Lista sectors po tych operacjach wygląda dokładnie tak samo jak na początku.

3. Promise.withResolvers()

Łatwiejsze tworzenie Promise z zewnętrznym resolve/reject. Przydaje się, gdy obietnicę trzeba rozstrzygnąć z innego miejsca niż jej konstruktor:

// Stary sposób - niewygodny
let externalResolve, externalReject;
const oldPromise = new Promise((resolve, reject) => {
  externalResolve = resolve;
  externalReject = reject;
});

// Nowy sposób z Promise.withResolvers()
const { promise, resolve, reject } = Promise.withResolvers();

// Teraz możemy resolve/reject z dowolnego miejsca
setTimeout(() => {
  resolve('Operacja zakończona!');
}, 1000);

promise.then(console.log); // "Operacja zakończona!" po 1 sekundzie

Stary sposób wymaga zmiennych zadeklarowanych przed konstruktorem, a Promise.withResolvers() od razu zwraca obiekt z trzema polami, które rozpakowujemy destrukturyzacją. Najlepiej widać to na czujniku, który obiecuje odczyt teraz, a dostarcza go później:

// Przydatne przy operacjach asynchronicznych sterowanych z zewnątrz
class DinosaurSensor {
  constructor(id) {
    this.id = id;
    const { promise, resolve, reject } = Promise.withResolvers();
    this.readingPromise = promise;
    this.resolveReading = resolve;
    this.rejectReading = reject;
  }

  receiveReading(data) {
    this.resolveReading(data);
  }

  sensorFailure(error) {
    this.rejectReading(error);
  }
}

const sensor = new DinosaurSensor("TREX-001");

// Ustalamy, co się stanie, gdy przyjdzie odczyt
sensor.readingPromise.then(reading => {
  console.log(`Czujnik ${sensor.id}: ${JSON.stringify(reading)}`);
});

// Później, gdy odczyt dotrze:
sensor.receiveReading({ temperature: 38.5, heartRate: 72 });

Konstruktor tworzy obietnicę i odkłada resolve oraz reject na później. Kod czekający na odczyt podpina się przez then(), a receiveReading() spełnia obietnicę dopiero wtedy, gdy przyjdą dane.

ES2025 - Najnowsze funkcje

1. Nowe metody Set

Operacje na zbiorach - wreszcie wbudowane w JavaScript! Każda metoda przyjmuje drugi zbiór i zwraca nowy Set albo wartość logiczną:

const carnivores = new Set(['Rex', 'Blue', 'Delta', 'Echo']);
const sectorA = new Set(['Rex', 'Sarah', 'Delta']);

// intersection() - elementy wspólne
const dangerousInA = carnivores.intersection(sectorA);
console.log([...dangerousInA]); // ['Rex', 'Delta']

// difference() - elementy tylko w pierwszym zbiorze
const safeInA = sectorA.difference(carnivores);
console.log([...safeInA]); // ['Sarah']

// union() - wszystkie elementy z obu zbiorów
const allKnown = carnivores.union(sectorA);
console.log([...allKnown]); // ['Rex', 'Blue', 'Delta', 'Echo', 'Sarah']

// symmetricDifference() - elementy tylko w jednym ze zbiorów
const exclusive = carnivores.symmetricDifference(sectorA);
console.log([...exclusive]); // ['Blue', 'Echo', 'Sarah']

// isSubsetOf() - czy jest podzbiorem
const smallGroup = new Set(['Rex', 'Blue']);
console.log(smallGroup.isSubsetOf(carnivores)); // true

// isSupersetOf() - czy zawiera wszystkie elementy
console.log(carnivores.isSupersetOf(smallGroup)); // true

// isDisjointFrom() - czy nie mają wspólnych elementów
const herbivores = new Set(['Sarah', 'Bronty', 'Tricy']);
console.log(carnivores.isDisjointFrom(herbivores)); // true

Pierwsze cztery metody zwracają nowy Set, a oryginalne zbiory zostają nietknięte. Metody z przedrostkiem is odpowiadają tylko true lub false, a spread zamienia wynik w tablicę, bo Set jest iterowalny.

Skoro mowa o zbiorach: struktura danych decyduje o szybkości. Dostęp po indeksie (array[0]) czy do właściwości obiektu (obj.key) ma stały koszt, zapisywany jako O(1), niezależny od liczby elementów. indexOf() i includes() w najgorszym razie przeglądają całą tablicę, czyli O(n), a sortowanie to zwykle O(n log n). Set.has() działa w praktyce w stałym czasie, więc przy częstym sprawdzaniu obecności zbiór wygrywa z tablicą.

2. Promise.try()

Bezpieczne wykonanie funkcji w kontekście Promise. Funkcja może zawieść na dwa sposoby: rzucić błąd od razu albo zwrócić odrzuconą obietnicę, a bez Promise.try() obie ścieżki trzeba obsłużyć osobno:

// Bez Promise.try - błędy synchroniczne i asynchroniczne obsługujemy osobno
function getDinosaurStatus(id) {
  return new Promise((resolve, reject) => {
    try {
      const result = syncOperation(id); // może rzucić błąd od razu
      resolve(asyncOperation(result));  // może zwrócić odrzuconą obietnicę
    } catch (e) {
      reject(e);
    }
  });
}

// Z Promise.try - czytelniej
function getDinosaurStatus(id) {
  return Promise.try(() => {
    const result = syncOperation(id);  // błąd synchroniczny zostanie złapany
    return asyncOperation(result);     // odrzucenie też
  });
}

// W praktyce: bezpieczne wykonanie dowolnej funkcji jako obietnicy
const safeCheck = Promise.try(() => {
  validateDinoId("RAPTOR-001"); // może rzucić błąd
  return fetchDinosaurData("RAPTOR-001"); // zwraca obietnicę
});

safeCheck
  .then(data => console.log("Dane:", data))
  .catch(err => console.error("Błąd:", err));

Promise.try() zamienia błąd rzucony synchronicznie w odrzuconą obietnicę, więc jedno .catch() łapie oba rodzaje awarii. Krótki test na funkcji, która rzuca błąd na żądanie:

function riskyOperation(shouldThrow) {
  if (shouldThrow) {
    throw new Error('Synchroniczny błąd!');
  }
  return 'Sukces';
}

// Nowy sposób z Promise.try()
const result = Promise.try(() => riskyOperation(false));
result.then(console.log); // 'Sukces'

const error = Promise.try(() => riskyOperation(true));
error.catch(err => console.error(err.message)); // 'Synchroniczny błąd!'

Oba wyniki trafiają do zwykłych then() i catch() - błąd synchroniczny nie przerwał programu, tylko stał się odrzuceniem.

3. Import Attributes (JSON Modules)

Importowanie JSON bezpośrednio. Atrybut with { type: 'json' } mówi środowisku, jakiego typu plik ładujemy:

// Importowanie pliku JSON z atrybutem typu
import dinoConfig from './dinosaurs.json' with { type: 'json' };

console.log(dinoConfig.species);

// Dynamiczny import z atrybutami
const config = await import('./config.json', { with: { type: 'json' } });

Atrybut to zabezpieczenie: jeśli serwer zamiast JSON-a zwróci skrypt, import się nie powiedzie, zamiast wykonać obcy kod. Składnia działa w modułach ES, które poznałeś wcześniej w tej lokacji.

Sprawdzanie wsparcia przeglądarki

Nowe funkcje nie trafiają do wszystkich przeglądarek jednocześnie. Zanim ich użyjesz, sprawdź, czy istnieją, porównując typ z napisem 'function':

const es2024Support = {
  objectGroupBy: typeof Object.groupBy === 'function',
  arrayToSorted: typeof [].toSorted === 'function', // formalnie ES2023
  arrayToReversed: typeof [].toReversed === 'function', // formalnie ES2023
  arrayWith: typeof [].with === 'function', // formalnie ES2023
  promiseWithResolvers: typeof Promise.withResolvers === 'function'
};

const es2025Support = {
  setIntersection: typeof Set.prototype.intersection === 'function',
  setDifference: typeof Set.prototype.difference === 'function',
  promiseTry: typeof Promise.try === 'function'
};

console.log('ES2024 Support:', es2024Support);
console.log('ES2025 Support:', es2025Support);

Takie wykrywanie funkcji (feature detection) jest pewniejsze niż zgadywanie po nazwie przeglądarki. Gdy funkcji brakuje, dołącz polyfill, czyli skrypt dopisujący brakującą metodę.

Podsumowanie

ES2024 i ES2025 przynoszą:

  1. Object.groupBy() / Map.groupBy() - grupowanie danych bez lodash i bez reduce()
  2. toSorted(), toReversed(), toSpliced(), with() - immutability bez spread operator (formalnie już od ES2023)
  3. Promise.withResolvers() - łatwiejsze zarządzanie Promise
  4. Metody Set - operacje na zbiorach wbudowane w język
  5. Promise.try() - jednolita obsługa błędów synchronicznych i asynchronicznych
  6. Import Attributes - jawna deklaracja typu importowanego modułu

Pamiętajcie, aby sprawdzać kompatybilność przeglądarek i w razie potrzeby używać polyfilli! Moja rada: po toSorted() i Object.groupBy() sięgaj śmiało, ale przy starszych przeglądarkach sprawdź tabelę zgodności na MDN. W kolejnej lekcji poznasz obserwatory wbudowane w przeglądarkę.

Pamiętaj: JavaScript ewoluuje jak gatunki w laboratorium - co roku przybywa nowych funkcji, ale przed wypuszczeniem na wybieg sprawdź, czy przeglądarka je rozpozna.

Hasła z dokumentacji w tej lekcji

Widzisz błąd w tej lekcji?

Sprawdź się

Odpowiedz na pytania z tej lekcji. Wybierz odpowiedź, a od razu zobaczysz, czy jest poprawna.

  1. 1. Co robi metoda Object.groupBy() wprowadzona w ES2024?

  2. 2. Czym toSorted() różni się od sort() w JavaScript?

To 2 z 3 pytań do tej lekcji. Pozostałe rozwiążesz w grze.

Zadania praktyczne w grze

  • Edytor kodu

    Pogrupuj dinozaury po typie, posortuj po zagrożeniu i zamień elementy bez mutacji.

  • Układanie w pionie

    Uporządkuj funkcje JavaScript chronologicznie według standardu ECMAScript:

  1. PytanieObject.groupBy() w ES2024
  2. PytanieMetody tablicowe bez mutacji
  3. Zadanie z kodemPraktyka: Nowe funkcje ES2023/ES2024
  4. Ułóż w kolejnościEwolucja standardu ECMAScript
  5. PytanieWydajność operacji na strukturach danych

Przydatne artykuły