3 ECMAScript: Sprachstandards und Versionen

ECMAScript bildet die standardisierte Grundlage für JavaScript und definiert die Syntax, Semantik und die Kernfunktionalitäten der Sprache. Um die Evolution von JavaScript zu verstehen, ist es essenziell, die verschiedenen ECMAScript-Versionen und deren Bedeutung für die moderne Webentwicklung zu kennen.

3.1 Die Standardisierung durch ECMA International

Die European Computer Manufacturers Association (heute ECMA International) übernahm 1996 die Aufgabe, JavaScript zu standardisieren, um eine einheitliche Implementierung über verschiedene Browser und Plattformen hinweg zu gewährleisten. Der Standard trägt die offizielle Bezeichnung ECMA-262 und definiert die Programmiersprache ECMAScript.

Wichtig zu verstehen ist die Beziehung zwischen ECMAScript und JavaScript:

3.2 Entwicklung der ECMAScript-Versionen

3.2.1 ECMAScript 1, 2 und 3 (1997-1999)

Die ersten drei Versionen bildeten das Fundament der Sprache:

// Beispiel für ES3-Features (1999)
try {
  // Code, der Fehler verursachen könnte
  var result = someUndefinedFunction();
} catch (error) {
  console.error("Ein Fehler ist aufgetreten:", error.message);
}

// Reguläre Ausdrücke in ES3
var pattern = /^[a-z]+$/i;
var isValid = pattern.test("JavaScript");

3.2.2 ECMAScript 4 und die Kontroverse

ECMAScript 4 sollte eine umfassende Überarbeitung bringen, wurde jedoch nie veröffentlicht. Unterschiedliche Visionen der beteiligten Unternehmen führten zu einer Spaltung in der Community. Dieser Konflikt verzögerte die Evolution von JavaScript um fast ein Jahrzehnt.

3.2.3 ECMAScript 5 (2009)

Nach einer zehnjährigen Pause brachte ES5 wichtige Verbesserungen:

// ES5-Features (2009)
"use strict"; // Aktivierung des Strict Mode

// Array-Methoden
var numbers = [1, 2, 3, 4, 5];
var doubled = numbers.map(function(num) {
  return num * 2;
});
var sum = numbers.reduce(function(acc, current) {
  return acc + current;
}, 0);

// Getter und Setter
var person = {
  firstName: "Max",
  lastName: "Mustermann",
  get fullName() {
    return this.firstName + " " + this.lastName;
  },
  set fullName(name) {
    var parts = name.split(" ");
    this.firstName = parts[0];
    this.lastName = parts[1];
  }
};

3.2.4 ECMAScript 5.1 (2011)

Eine redaktionelle Überarbeitung ohne wesentliche Funktionsänderungen, die hauptsächlich Klarstellungen und Korrekturen enthielt.

3.2.5 ECMAScript 6 / ES2015

Die umfangreichste Aktualisierung in der Geschichte von JavaScript, die zahlreiche neue Sprachfeatures einführte:

// ES6/ES2015-Features (2015)
// Blockscoping
let x = 10;
const PI = 3.14159;

// Arrow Functions
const square = (x) => x * x;

// Klassen
class Rectangle {
  constructor(width, height) {
    this.width = width;
    this.height = height;
  }
  
  get area() {
    return this.width * this.height;
  }
}

// Template Strings
const name = "Welt";
console.log(`Hallo, ${name}!`);

// Destrukturierung
const [a, b] = [1, 2];
const {firstName, lastName} = person;

// Module
import { Component } from './component';
export default class MyComponent extends Component {};

3.2.6 Jährliche Releases seit 2016

Seit ES2015 wurde auf ein jährliches Release-Modell umgestellt, bei dem inkrementelle Updates anstelle großer Versionen veröffentlicht werden:

// Ausgewählte Features neuerer ECMAScript-Versionen

// ES2017: async/await
async function fetchData() {
  try {
    const response = await fetch('https://api.example.com/data');
    const data = await response.json();
    return data;
  } catch (error) {
    console.error('Fehler beim Laden der Daten:', error);
  }
}

// ES2020: Optional Chaining und Nullish Coalescing
const user = {
  profile: {
    // address könnte fehlen
  }
};

// Ohne Optional Chaining
const city1 = user.profile && user.profile.address && user.profile.address.city;

// Mit Optional Chaining
const city2 = user.profile?.address?.city;

// Nullish Coalescing
const username = user.username ?? 'Anonymer Benutzer'; // null/undefined → Fallback

3.3 Der Standardisierungsprozess

Der ECMAScript-Standardisierungsprozess wird vom Technical Committee 39 (TC39) überwacht und folgt einem definierten Stufenmodell:

  1. Stage 0 (Strawperson): Initiale Ideen und Vorschläge
  2. Stage 1 (Proposal): Formaler Vorschlag mit einem Champion
  3. Stage 2 (Draft): Erste Version der Spezifikation
  4. Stage 3 (Candidate): Spezifikation ist nahezu vollständig
  5. Stage 4 (Finished): Bereit für Aufnahme in den Standard

3.4 Implementierungsstatus und Browser-Kompatibilität

Nicht alle JavaScript-Engines implementieren alle ECMAScript-Features sofort. Die Unterstützung variiert je nach Browser und Version:

Für die praktische Entwicklung bedeutet dies, dass Entwickler Transpiler wie Babel oder TypeScript einsetzen, um moderne JavaScript-Features auch in älteren Umgebungen nutzen zu können. Diese Tools übersetzen neuere Syntax in ältere, kompatible Varianten.

3.5 ECMAScript und die JavaScript-Ökosysteme

Die ECMAScript-Standards definieren nur die Kernsprache. Viele JavaScript-APIs, die Entwickler täglich nutzen, sind in separaten Standards definiert:

Diese Unterscheidung erklärt, warum bestimmte Features wie document oder window in Browsern verfügbar sind, aber nicht in Node.js, und umgekehrt.

3.6 Zukunft von ECMAScript

Die Zukunft von ECMAScript wird durch die aktuellen Proposals im TC39-Prozess geprägt. Einige interessante Proposals in verschiedenen Stages (Stand 2024) sind:

Die genaue Entwicklung dieser Features wird im Kapitel “Zukunft von JavaScript” detaillierter behandelt.