Was ist JavaScript?

Was ist JavaScript?

JavaScript ist eine High-Level-Sprache, die zur Laufzeit interpretiert und im Hot-Path JIT-kompiliert wird. Sie ist dynamisch typisiert, garbage-collected und vereint mehrere Paradigmen: imperativ, funktional und prototyp-basiert objektorientiert. Klassen sind seit ES2015 syntaktischer Zucker auf dem Prototyp-Modell.

Drei Eigenschaften praegen den taeglichen Umgang mit der Sprache:

• Single-threaded mit Event-Loop: ein Thread pro Realm, asynchrone Arbeit über Microtasks (Promises) und Macrotasks (Timer, I/O).
• First-Class Functions: Funktionen sind Werte, können übergeben, gespeichert und zurückgegeben werden.
• Prototyp-Vererbung: Objekte erben von anderen Objekten direkt, ohne Klassen-Hierarchie zwingend zu sein.

Ursprünglich war JavaScript für kleine Browser-Skripte gedacht. Heute laufen damit Datenbank-Treiber, Build-Tools, Cloud-Funktionen und ganze Backends. Diese Reichweite verdankt die Sprache vor allem zwei Dingen: einem stabilen, jährlich erweiterten Standard und mehreren konkurrierenden, hoch-optimierten Engines.

JavaScript vs. ECMAScript

Die Begriffe werden oft synonym verwendet, sind es aber nicht. ECMAScript ist der Sprachstandard, spezifiziert in ECMA-262 durch die Ecma International und gepflegt vom Komitee TC39. JavaScript ist die populärste Implementierung dieses Standards und gleichzeitig ein eingetragenes Markenzeichen (ehemals Sun Microsystems, heute Oracle).

Es gab und gibt mehrere Implementierungen des Standards:

• JavaScript — Mozilla, Browser-Engines, Node.js, Bun. De-facto-Standard.
• JScript — Microsofts Variante in alten Internet-Explorer-Versionen, eingestellt.
• ActionScript — Adobe Flash, basierte auf einem ES4-Entwurf, der nie ratifiziert wurde.

Wenn ein Artikel von „ES2020" oder „ES2025" spricht, meint er die jährliche Edition des ECMA-262-Standards. „JavaScript-Version" ist ein umgangssprachlicher Ausdruck, technisch sauber waere stets die ECMAScript-Edition.

Geschichte im Schnelldurchlauf

JavaScript entstand 1995 in nur zehn Tagen: Brendan Eich schrieb für Netscape einen Prototyp namens „Mocha", später „LiveScript", schließlich „JavaScript" — eine Marketing-Entscheidung im Windschatten der damals populären Sprache Java. Beide Sprachen haben jedoch außer dem Namen wenig gemeinsam.

Eine grobe Zeitleiste:

• 1997 — ECMAScript 1, erste Standardisierung durch Ecma.
• 1999 — ES3, mit Try/Catch und Regex; die Basis für das Web der 2000er.
• 2000–2008 — ES4 scheitert nach jahrelangem Streit, viele Ideen wandern später in ES6.
• 2009 — ES5 mit Strict Mode, JSON, getter/setter und Array-Methoden wie forEach, map.
• 2015 — ES6/ES2015 als kompletter Reset: let/const, Arrow Functions, Klassen, Template Literals, Destructuring, ES Modules, Promises.
• seit 2016 — jährliche Releases im Juni, jeder Release inkrementell.
• 2025 — ES2025 ratifiziert (Iterator Helpers, Set-Methoden, Promise.try).
• 2026 — ES2026 als Working Draft.

Die Wende kam mit ES2015. Davor gab es jahrelange Pausen ohne neue Versionen, danach hat TC39 auf einen jährlichen Release-Zug umgeschwenkt — kleinere Schritte, dafür planbar.

Engines

Eine JavaScript-Engine parst Quelltext, erzeugt Bytecode, fuehrt ihn in einem Interpreter aus und kompiliert heisse Funktionen zu nativem Maschinencode (JIT). Drei große Engines dominieren das Feld:

• V8 — Google. Antrieb von Chrome, Edge, Node.js, Deno, Electron. Mehrstufiger JIT (Ignition + TurboFan + Maglev + Sparkplug).
• SpiderMonkey — Mozilla. Erste JS-Engine überhaupt (1996 von Brendan Eich). Heute mit Warp/IonMonkey-JIT.
• JavaScriptCore (JSC) — Apple/WebKit. Antrieb von Safari und Bun. Vier-Tier-JIT (LLInt + Baseline + DFG + FTL).

Alle Engines implementieren ECMA-262 plus die für ihre Plattform relevanten Web-APIs. Im Browser bekommen sie zusaetzlich eine DOM-Implementierung, in Node.js stattdessen Bindings zu libuv und V8 selbst.

// typeof zur Laufzeit — kein Compiler kennt den Typ vorher
console.log(typeof 42);            // "number"
console.log(typeof "Hallo");       // "string"
console.log(typeof true);          // "boolean"
console.log(typeof undefined);     // "undefined"
console.log(typeof null);          // "object"  (historischer Bug, im Standard zementiert)
console.log(typeof Symbol("id"));  // "symbol"
console.log(typeof 42n);           // "bigint"
console.log(typeof function () {}); // "function"
console.log(typeof []);            // "object"  — Array.isArray([]) -> true

// Eine Variable kann ihren Typ wechseln — für JIT-Optimierungen
// ist das aber teuer. Stabile Typen erlauben Inline-Caches.
let x = 1;
x = "jetzt String";
x = { jetzt: "Objekt" };

Ausfuehrungsumgebungen

Eine Engine allein ist nicht ausfuehrbar — sie braucht eine Laufzeit, die globale Objekte, I/O und einen Event-Loop bereitstellt. Die vier wichtigsten Laufzeiten heute:

Welche Laufzeit passt, haengt vom Einsatzgebiet ab:

• Browser für alles UI-nahe — Single-Page-Apps, statische Sites mit Hydration, Browser-Erweiterungen.
• Node.js als Klassiker für Backends, CLIs und Build-Tools. Riesiges npm-Oekosystem.
• Deno für sichere Skripte und kleine Services. Permissions-Modell, TypeScript out of the box.
• Bun als schneller Drop-in-Ersatz für Node.js, eingebauter Bundler, Test-Runner und Package-Manager.

Browser vs. Node.js — was ist wo?

Der Sprachkern (Array, Object, Promise, Map, Set, Number, String, Date, RegExp, Iteratoren) ist in jeder Laufzeit identisch. Unterschiede liegen in den Globals und in den Plattform-APIs:

• Browser: window, document, navigator, localStorage, XMLHttpRequest, DOM-Events, IndexedDB, Web Workers.
• Node.js: process, Buffer, __dirname, require, globalThis, Module wie fs, path, http, crypto, worker_threads.
• Beide: fetch, URL, URLSearchParams, console, setTimeout, Promise, structuredClone (seit Node 17).

Eine Bibliothek, die nur den Sprachkern nutzt (z. B. eine Datums-Library, ein Validator, ein Math-Helfer), läuft in allen Laufzeiten ohne Anpassung. Sobald sie auf document oder fs zugreift, wird sie plattformspezifisch.

// Gleiche Logik — einmal funktional, einmal imperativ.
const numbers = [1, 2, 3, 4, 5, 6];

// Funktional: deklarativ, kette von Transformationen
const sumOfSquaresEvenFn = numbers
    .filter(n => n % 2 === 0)
    .map(n => n * n)
    .reduce((acc, n) => acc + n, 0);

// Imperativ: Schleife mit explizitem Zustand
let sumOfSquaresEvenIm = 0;
for (let i = 0; i < numbers.length; i++) {
    const n = numbers[i];
    if (n % 2 !== 0) continue;
    sumOfSquaresEvenIm += n * n;
}

console.log(sumOfSquaresEvenFn, sumOfSquaresEvenIm);

56 56

Dynamisch typisiert — was heisst das?

Eine dynamisch typisierte Sprache prüft Typen erst zur Laufzeit. Der Operator typeof liefert den Typ eines Werts, eine Variable selbst hat keinen festen Typ:

• Vorteil: schnelles Prototyping, weniger Boilerplate, flexible Datenstrukturen.
• Nachteil: Type-Errors zeigen sich erst, wenn der Code läuft. Tooling muss kompensieren (Linter, Tests).

TypeScript schiebt eine statische Typebene davor: Typen werden zur Build-Zeit geprüft und beim Kompilieren entfernt. Das fertige JavaScript hat keine Typannotationen mehr und läuft in jeder Engine. Das Stage-1-Proposal Type Annotations as Comments (früher „types as comments") will eine TS-aehnliche Syntax direkt im Standard verankern, sodass Engines die Annotationen einfach ignorieren — Stand 2026 noch nicht in einer Spec-Edition.

JavaScript heute — wo es überall läuft

Die Sprache hat sich vom Browser-Skript zum universellen Werkzeug entwickelt:

• Browser-SPAs mit Frameworks wie Angular, React, Vue, Svelte, Solid.
• Server mit Node.js, Deno oder Bun — REST-APIs, GraphQL-Server, gRPC-Backends.
• Mobile über React Native, Capacitor oder NativeScript — JavaScript-Logik über nativen UI-Bridges.
• Desktop mit Electron (Chromium + Node) oder Tauri (Webview + Rust).
• Embedded über Espruino, Moddable XS, IoT.js auf Mikrocontrollern.
• Cloud-Funktionen in Cloudflare Workers, AWS Lambda, Vercel Edge, Deno Deploy.
• Build-Tooling — Vite, esbuild, Rollup, Webpack, swc, Biome.

Diese Allgegenwart bedeutet auch: das Wissen über den Sprachkern ist transferierbar. Wer Promise, async/await und Iteratoren versteht, ist sowohl im Frontend als auch im Backend produktiv.

Hello World — drei Wege

Die einfachste Form von „Code ausfuehren" reicht oft, um eine Idee zu testen. Drei klassische Wege:

Browser-Console

Jeder moderne Browser hat eine eingebaute REPL. F12 oeffnet die DevTools, dann der Tab „Console":

console.log("Hello, Browser!");
// Funktioniert sofort, ohne Build-Step, ohne Datei.
2 ** 10;

Hello, Browser!
1024

Node-REPL

Mit installiertem Node.js startet node ohne Argument eine interaktive Shell:

$ node
Welcome to Node.js v22.11.0.
Type ".help" for more information.
> console.log("Hello, Node!")
Hello, Node!
> [1, 2, 3].map(n => n * n)
[ 1, 4, 9 ]
> .exit

Hello, Node!
[ 1, 4, 9 ]

Datei ausfuehren

Für mehr als ein paar Zeilen lohnt sich eine .js-Datei:

// hello.js
const name = "Welt";
console.log(`Hello, ${name}!`);

$ node hello.js
Hello, Welt!

Weiterfuehrende Ressourcen

Externe Quellen

• JavaScript Guide — Introduction (MDN)
• JavaScript technologies overview (MDN)
• ECMA-262 — TC39
• V8 Engine — Blog
• SpiderMonkey — Mozilla

Verwandte Artikel

• Erste Schritte mit JavaScript
• Strict Mode
• ECMAScript-Versionen
• JavaScript-Engine — Mental Model
• Variablen: var, let, const
• Datentypen: Primitives und Objects
• Arrow Functions