ECMAScript 2025 wurde im Juni 2024 durch die Ecma General Assembly als 16. Edition der Sprachspezifikation ratifiziert. Anders als frühere Releases bündelt ES2025 keine einzelne Headline-Funktion, sondern eine Reihe sehr praktischer Ergänzungen, die Standard-Library, Modul-System und reguläre Ausdrücke betreffen. Wer 2026 produktiv schreibt, kommt an Iterator-Helpers, Set-Methods und Import-Attributes praktisch nicht mehr vorbei — die Browser-Verfügbarkeit ist mittlerweile durchgängig.

Iterator-Helpers — lazy Pipelines ohne Array-Allokationen

Bisher war jeder, der eine Pipeline aus map, filter und take schreiben wollte, gezwungen, entweder Zwischen-Arrays zu allozieren oder auf eine Third-Party-Library wie lodash oder iter-ops zurückzugreifen. Die Iterator-Helpers landen jetzt direkt auf Iterator.prototype und arbeiten lazy — eine Operation pro Element, ohne Zwischenspeicherung.

// Vorher: Array-Zwischenstufen
const result = [...iter]
  .filter(x => x.active)
  .map(x => x.value)
  .slice(0, 10);

// ES2025: lazy, kein Zwischen-Array
const result = iter
  .filter(x => x.active)
  .map(x => x.value)
  .take(10)
  .toArray();

Die Methoden umfassen .map(), .filter(), .take(n), .drop(n), .flatMap(), .reduce(), .toArray(), .forEach(), .some(), .every() und .find(). Sie funktionieren mit jedem Iterator — also auch mit Map.prototype.entries(), mit Set.prototype.values() oder mit eigenen Generator-Funktionen. Bei Streams mit zehntausenden Elementen ist der Speicherunterschied erheblich: Eine Pipeline, die früher fünf Zwischen-Arrays angelegt hat, läuft jetzt mit O(1)-Zusatzspeicher pro Element.

Browser-Support ist seit Mitte 2024 stabil: Chrome 122, Firefox 131, Safari 18.4. Wer ältere Targets bedienen muss, nutzt core-js/actual/iterator als Polyfill — der Footprint ist mit etwa 4 kB minified-gzipped übersichtlich.

Set-Methods — endlich erste Mengenoperationen in der Standard-Library

Set war seit ES2015 in der Sprache, ohne dass die Standard-Library jemals eine Vereinigung oder eine Schnittmenge angeboten hätte. ES2025 schließt diese Lücke mit sieben Methoden:

const a = new Set([1, 2, 3, 4]);
const b = new Set([3, 4, 5, 6]);

a.union(b);              // Set { 1, 2, 3, 4, 5, 6 }
a.intersection(b);       // Set { 3, 4 }
a.difference(b);         // Set { 1, 2 }
a.symmetricDifference(b);// Set { 1, 2, 5, 6 }

a.isSubsetOf(b);         // false
a.isSupersetOf(b);       // false
a.isDisjointFrom(b);     // false

Die Argumente werden als SetLike-Interface erwartet — also mit size, has() und keys(). Das heißt, man kann auch eine Map direkt übergeben, ohne sie vorher in ein Set zu konvertieren. Die Komplexität ist erwartbar: union und intersection sind O(n+m), die is*Of-Prüfungen brechen früh ab, sobald eine Verletzung gefunden wird.

Das RegExp-v-Flag — Unicode-Set-Notation

Das v-Flag (für „unicodeSets”) ist eine strengere Variante des u-Flags und erlaubt erstmals Set-Operationen direkt in Character-Classes. Subtraktion, Schnittmenge und Verschachtelung waren bisher nur über umständliche Lookahead-Konstruktionen möglich.

// Alle Buchstaben, die KEINE ASCII-Buchstaben sind
const nonAscii = /[\p{Letter}--[a-zA-Z]]/v;

// Schnittmenge: griechische Buchstaben, die Kleinbuchstaben sind
const greekLower = /[\p{Script=Greek}&&\p{Lowercase}]/v;

// String-Properties statt nur Code-Point-Properties
const emoji = /\p{RGI_Emoji}/v;

Besonders relevant ist der Zugriff auf String-Properties wie \p{RGI_Emoji} — ein einzelnes Emoji wie 🇩🇪 besteht aus zwei Code-Points (Regional-Indicator D + E), das u-Flag konnte das nicht als Einheit matchen, das v-Flag schon. Implementierungs-Stand: Chrome 112, Safari 17, Firefox 116 — also lange stabil.

Import-Attributes — JSON-Module ohne Build-Step

Die Syntax mit assert ist tot, die Syntax mit with ist der Standard:

// ES2025 / HTML-Spec
import config from './config.json' with { type: 'json' };
import styles from './styles.css' with { type: 'css' };

// Dynamische Imports
const data = await import('./data.json', {
  with: { type: 'json' }
});

Das type-Attribut ist verpflichtend, weil Browser sonst aus Sicherheitsgründen das MIME-Type-Mismatch zurückweisen. Eine JSON-Datei, die mit Content-Type: application/json ausgeliefert wird, darf nicht als JavaScript-Modul interpretiert werden — das Attribut ist die explizite Zustimmung der aufrufenden Seite. CSS-Module sind in Chromium-Browsern verfügbar, in Firefox und Safari noch nicht durchgängig.

Stage-3-Proposals — was 2026 nachrückt

Die TC39-Pipeline hat eine Reihe von Proposals, die seit längerem auf Stage 3 stehen und nun Browser-Implementierungen sammeln:

• Decorators — final auf Stage 3 angekommen, mit einer Semantik, die sich von der TypeScript-Experimental-Variante unterscheidet. TypeScript 5.0 hat die neue Syntax bereits 2023 eingebaut. V8 hat ein Implementation-Flag, Stage 4 wird für 2026 erwartet.
• Pipeline-Operator (|>) — nach einer sehr langen Stage-2-Phase mit Streit über die Hack-Style- vs. F#-Style-Variante hat sich die TC39 für eine Hack-Style-Variante mit Topic-Token % entschieden. Implementierungs-Stand ist gering.
• Records & Tuples — Immutable-Primitives mit eigener typeof-Identität (record und tuple). Das Proposal liegt seit 2022 auf Stage 2, eine Stage-3-Promotion ist 2026 wahrscheinlich, aber nicht sicher — vor allem die ===-Semantik auf strukturelle Gleichheit ist umstritten.
• Temporal — die Date-Replacement-API hat sich nach Jahren der Entwicklung stabilisiert. Firefox hat sie 2025 hinter einem Flag ausgeliefert, Chrome ist in der Implementierungs-Phase. Stage 4 wird für Mitte 2026 erwartet.

Polyfill-Status und Browser-Verfügbarkeit

Für Projekte, die ältere Browser bedienen müssen, ist [email protected] (Stand Anfang 2026) der pragmatische Ansatz. Die ES2025-Features sind alle abgedeckt, der Footprint hängt davon ab, was tatsächlich importiert wird:

Feature	Chrome	Firefox	Safari	core-js-Pfad
Iterator-Helpers	122	131	18.4	actual/iterator
Set-Methods	122	127	17	actual/set
RegExp v-Flag	112	116	17	nicht polyfillbar
Import-Attributes	123	130	17.5	nicht polyfillbar

Das v-Flag und Import-Attributes lassen sich nicht polyfillen, weil sie auf Parser-Ebene wirken — hier hilft nur ein Build-Step mit Babel-Plugin oder ein Build-Target, das die entsprechenden Engines voraussetzt. Für die anderen Features gilt: wer mit useBuiltIns: "usage" in Babel oder mit core-js als unplugin-auto-import-Source arbeitet, hat 2026 keinen Grund mehr, auf die Sprach-Features zu verzichten.

Zusammenfassung

ES2025 ist kein Marketing-Release, sondern eine Sammlung lange überfälliger Quality-of-Life-Verbesserungen. Iterator-Helpers ersetzen einen erheblichen Teil dessen, wofür man bislang lodash oder rxjs gezogen hat. Set-Methods schließen eine Lücke, die seit zehn Jahren offen war. Das v-Flag macht Unicode-RegExp endlich brauchbar. Import-Attributes räumen den letzten Hack aus dem Modul-System.

Für 2026 sind Decorators und Temporal die heißesten Kandidaten auf Stage 4 — beide haben Implementations-Momentum, beide sind in den großen Frameworks bereits eingeplant. Records & Tuples sind weiter offen, der Pipeline-Operator ist es ebenfalls. Wer heute schreibt, sollte sich auf die ES2025-Features verlassen und für die Stage-3-Kandidaten die TypeScript- oder Babel-Variante einsetzen, bis die Browser nachziehen.