JavaScript-Datentypen

Einführung in JavaScript-Datentypen

JavaScript ist eine dynamisch typisierte Sprache: Der Typ einer Variablen wird nie deklariert, und eine Variable kann einen Wert beliebigen Typs halten — sogar einen anderen Typ zu einem späteren Zeitpunkt. Da die Engine, nicht du, die Typen zur Laufzeit verfolgt, ist das genaue Wissen darüber, wie sich jeder Typ verhält, der Unterschied zwischen vorhersehbarem Code und rätselhaften Fehlern.

let x = 42;        // x is now a number
x = "forty-two";   // the same variable now holds a string — perfectly legal

Die Sprache definiert acht Datentypen: sieben Primitive und einen Nicht-Primitiven (object). Diese Seite behandelt jeden einzelnen, wie man ihn mit typeof prüft, und die Typumwandlungsregeln, über die die meisten Einsteiger stolpern.

Primitive Datentypen

Ein Primitiv ist ein Wert, der kein object ist und keine eigenen Methoden besitzt. Primitive sind unveränderlich — man kann einen primitiven Wert nie ändern, sondern nur die Variable ersetzen, die ihn hält.

• Number: Ganzzahlige oder Gleitkommazahlen sowie die Sonderwerte Infinity, -Infinity und NaN (Not a Number). Siehe Numbers.
• String: Textdaten, eingeschlossen in doppelte Anführungszeichen, einfache Anführungszeichen oder Backticks. Siehe Strings.
• Boolean: Einer von zwei logischen Werten, true oder false.
• Undefined: Eine Variable, die deklariert, aber nicht mit einem Wert belegt wurde.
• Null: Das bewusste Fehlen eines object-Wertes.
• BigInt: Ganzzahlen jenseits des sicheren Limits des Number-Typs. Siehe BigInt.
• Symbol: Ein garantiert eindeutiger Bezeichner, hauptsächlich als object-Schlüssel verwendet. Siehe Symbol type.

Nicht-Primitiver Datentyp

• Object: Eine Sammlung von Schlüssel/Wert-Eigenschaften zur Modellierung komplexer Daten. Arrays, Funktionen, Datumsangaben und die meisten eingebauten Typen sind im Grunde alle objects. Siehe Objects.

Einen Typ mit typeof prüfen

Um herauszufinden, welchen Typ ein Wert hat, stellt JavaScript den typeof-Operator bereit. Er gibt eine Zeichenkette zurück, wie "number", "string" oder "boolean".

Zwei Ergebnisse überraschen Neulinge:

• typeof null gibt "object" zurück. Dies ist ein Fehler aus der allerersten Version von JavaScript, der nie behoben werden kann, ohne das Web zu beschädigen — merke es dir einfach.
• typeof einer Funktion gibt "function" zurück. Funktionen sind eigentlich objects, aber typeof behandelt sie besonders, damit aufrufbare Werte erkannt werden können.

Arbeiten mit primitiven Datentypen

Im Folgenden wird jedes Primitiv mit einem minimalen Beispiel gezeigt, das ausgeführt werden kann.

Number: Das Fundament mathematischer Operationen

let age = 25;       // Integer
let price = 99.99;  // Floating-point
console.log(typeof age);   // "number"
console.log(0.1 + 0.2);    // 0.30000000000000004  (floating-point rounding)

Ein einziger number-Typ deckt sowohl Ganzzahlen als auch Dezimalzahlen ab. Da Zahlen 64-Bit-Gleitkomma verwenden, ist die Bruchrechnung nicht immer exakt — 0.1 + 0.2 ist das klassische Beispiel. Zahlen beinhalten auch Infinity und NaN; NaN ist bekanntlich nicht gleich sich selbst, daher sollte Number.isNaN(x) zur Prüfung verwendet werden.

String: Mehr als nur Text

let greeting = "Hello, world!";
let name = 'Ada';
let response = `Hi, ${name}!`; // template literal with interpolation
console.log(typeof greeting); // "string"
console.log(response);        // "Hi, Ada!"

Strings sind unveränderlich: Methoden wie toUpperCase() geben einen neuen string zurück, anstatt das Original zu ändern. Backtick-Strings (Template-Literale) ermöglichen das Einbetten von ${Ausdrücken} und das Erstrecken über mehrere Zeilen. Erkunde das vollständige Werkzeugset in Strings.

Boolean: Der binäre Entscheidungsträger

let isAvailable = true;
let age = 25;
let isAdult = age >= 18; // comparisons produce booleans
console.log(typeof isAvailable); // "boolean"
console.log(isAdult);            // true

Booleans steuern jede Bedingung und Schleife. Jeder Wert kann auch zu einem boolean umgewandelt werden — siehe die Truthy/Falsy-Tabelle weiter unten.

Undefined und Null: Das Fehlen eines Wertes

let notAssigned;          // declared but never given a value
let emptyOnPurpose = null; // deliberately "nothing"
console.log(typeof notAssigned);  // "undefined"
console.log(typeof emptyOnPurpose); // "object" (the typeof null quirk)
console.log(null == undefined);   // true  (loose equality)
console.log(null === undefined);  // false (strict equality — different types)

Verwende undefined für „noch kein Wert" (das ist, was JavaScript automatisch zuweist), und null für „absichtlich leer". Sie sind lose gleich (==), aber nicht streng gleich (===).

BigInt: Große Zahlen verarbeiten

const big = 9007199254740991n; // note the trailing n
console.log(typeof big);     // "bigint"
console.log(big + 1n);       // 9007199254740992n

Number kann Ganzzahlen nur sicher bis zu Number.MAX_SAFE_INTEGER (ca. 9 Billiarden) darstellen. Für alles Größere — Kryptografie, hochpräzise IDs — verwende BigInt, geschrieben mit einem abschließenden n. BigInt und Number können in derselben Rechenoperation ohne explizite Konvertierung nicht gemischt werden. Mehr dazu in BigInt.

Symbol: Eindeutigkeit sicherstellen

Jeder Symbol()-Aufruf gibt einen brandneuen, eindeutigen Wert zurück, selbst wenn der Beschreibungstext übereinstimmt. Symbols werden als kollisionssichere object-Schlüssel verwendet, zum Beispiel um Metadaten anzuhängen, ohne mit normalen string-Schlüsseln in Konflikt zu geraten. Siehe Symbol type.

Objects: Die Bausteine komplexer Strukturen

In JavaScript speichern objects Sammlungen zusammengehöriger Daten als Schlüssel/Wert-Paare und bilden die Grundlage für Arrays, Funktionen und die meisten eingebauten Typen.

let person = {
  name: "John",
  age: 30,
  isStudent: false
};
console.log(typeof person);     // "object"
console.log(typeof [1, 2, 3]);  // "object"  (arrays are objects)
console.log(Array.isArray([1])); // true — the reliable way to detect arrays

Objects sind veränderlich — anders als Primitive können Eigenschaften hinzugefügt, geändert und gelöscht werden. Sie werden auch per Referenz verglichen, nicht per Wert: Zwei objects mit identischem Inhalt sind nicht === gleich.

Typumwandlung und Konvertierung

Da JavaScript dynamisch typisiert ist, wandelt es einen Wert während einer Operation oft von einem Typ in einen anderen um. Das ist praktisch, aber eine häufige Quelle für Überraschungen.

Im Zweifelsfall explizit konvertieren mit Number(), String() oder Boolean(), anstatt sich auf automatische Typumwandlung zu verlassen.

Truthy- und Falsy-Werte

Wenn ein Wert dort verwendet wird, wo ein boolean erwartet wird (ein if, &&, ||), wird er umgewandelt. Genau sechs Werte sind falsy; alles andere ist truthy:

// falsy: false, 0, "", null, undefined, NaN
if ("") console.log("won't run");      // "" is falsy
if ("0") console.log("this runs");     // non-empty string is truthy
if ([]) console.log("this runs too");  // empty array is truthy!

Eine häufige Falle: Ein leeres array [] und ein leeres object {} sind truthy, obwohl "" und 0 falsy sind.

Zusammenfassung

JavaScript hat acht Datentypen — sieben Primitive (number, string, boolean, undefined, null, bigint, symbol) und das object. typeof gibt den Typ an, mit den bekannten Besonderheiten, dass typeof null "object" ist und Funktionen "function" zurückgeben. Primitive sind unveränderlich und werden per Wert verglichen; objects sind veränderlich und werden per Referenz verglichen. Wer Typumwandlung und die Truthy/Falsy-Regeln beherrscht, dem verschwindet das meiste „seltsame JavaScript". Als Nächstes sieh, wie Werte in Variablen gespeichert werden.

Übungen