Datentypen

JavaScript ist eine dynamisch typisierte Programmiersprache, was bedeutet, dass Variablen nicht an einen festen Datentyp gebunden sind. Stattdessen wird der Typ einer Variable zur Laufzeit bestimmt. Dies bietet Flexibilität, erfordert aber auch ein solides Verständnis der verschiedenen Datentypen, um unerwartetes Verhalten zu vermeiden.

In JavaScript lassen sich Datentypen in zwei Hauptkategorien einteilen: primitive (einfache) Datentypen und nicht-primitive (komplexe/referenzielle) Datentypen.

Primitive Datentypen (Wertetypen)

Primitive Datentypen sind unveränderlich (immutable) und werden direkt als Wert gespeichert. Wenn eine Variable mit einem primitiven Typ einer anderen Variable zugewiesen wird, wird eine Kopie des Werts erstellt.

number – Zahlen
JavaScript kennt keine Unterscheidung zwischen Ganzzahlen (integers) und Fließkommazahlen (floats). Alle Zahlen werden als 64-Bit-Gleitkommazahl (IEEE 754 Standard) behandelt.

let ganzzahl = 42;  
let kommazahl = 3.14;  
let wissenschaftlicheNotation = 2.5e4; // 25000  
let infinity = Infinity;  
let notANumber = NaN; // "Not a Number" (z. B. bei 0/0)  

let ganzzahl = 42;  
let kommazahl = 3.14;  
let wissenschaftlicheNotation = 2.5e4; // 25000  
let infinity = Infinity;  
let notANumber = NaN; // "Not a Number" (z. B. bei 0/0)  

string – Zeichenketten
Strings repräsentieren Text und werden in einfachen ( ‚ ‚ ), doppelten ( “ “ ) oder Backticks ( ` ` ) definiert. Template-Literals (Backticks) erlauben mehrzeilige Strings und Interpolation.

let name = "Max";  
let begruessung = `Hallo, ${name}!`; // Interpolation  
let mehrzeilig = `Zeile 1  
Zeile 2`;  

let name = "Max";  
let begruessung = `Hallo, ${name}!`; // Interpolation  
let mehrzeilig = `Zeile 1  
Zeile 2`;  

boolean – Wahrheitswerte
Ein Boolean kann nur true oder false sein und wird oft in Bedingungen verwendet.

let istWahr = true;  
let istFalsch = false;  
if (istWahr) {  
    console.log("Es ist wahr!");  
}  

let istWahr = true;  
let istFalsch = false;  
if (istWahr) {  
    console.log("Es ist wahr!");  
}  

null – Absichtliche Leere
null ist ein expliziter Wert, der „kein Objekt“ oder „kein Wert“ darstellt. Es ist ein bewusst gesetzter Platzhalter.

let leereVariable = null;  

let leereVariable = null;  

undefined – Nicht definiert
Wenn eine Variable deklariert, aber nicht initialisiert wurde, ist ihr Wert undefined .

let x;  
console.log(x); // undefined  

let x;  
console.log(x); // undefined  

symbol – Eindeutige Identifikatoren (ES6)
Ein Symbol erzeugt einen garantiert eindeutigen Wert, der oft als Objekteigenschaft verwendet wird, um Namenskonflikte zu vermeiden.

let id = Symbol("beschreibung");  
let obj = { [id]: 123 };  
console.log(obj[id]); // 123  

let id = Symbol("beschreibung");  
let obj = { [id]: 123 };  
console.log(obj[id]); // 123  

bigint – Sehr große Zahlen (ES2020)
Für Zahlen, die größer sind als Number.MAX_SAFE_INTEGER (2^53 – 1), kann BigInt verwendet werden.

let riesigeZahl = 9007199254740991n;  
console.log(riesigeZahl + 1n); // 9007199254740992n  

let riesigeZahl = 9007199254740991n;  
console.log(riesigeZahl + 1n); // 9007199254740992n  

Nicht-primitive Datentypen (Referenztypen)

Nicht-primitive Datentypen sind veränderlich (mutable) und werden als Referenz gespeichert. Wenn eine Variable mit einem Referenztyp einer anderen zugewiesen wird, zeigen beide auf denselben Speicherort.

object – Objekte
Objekte sind Sammlungen von Schlüssel-Wert-Paaren ( properties ). Sie können beliebige Daten enthalten.

let person = {  
    name: "Anna",  
    alter: 30,  
    adresse: {  
        stadt: "Berlin"  
    }  
};  
console.log(person.name); // "Anna"  

let person = {  
    name: "Anna",  
    alter: 30,  
    adresse: {  
        stadt: "Berlin"  
    }  
};  
console.log(person.name); // "Anna"  

array – Arrays (Spezialfall von Objekten)
Arrays sind geordnete Listen, die über numerische Indizes zugänglich sind.

let farben = ["rot", "grün", "blau"];  
console.log(farben[0]); // "rot"  

let farben = ["rot", "grün", "blau"];  
console.log(farben[0]); // "rot"  

function – Funktionen (Callable Objects)
Funktionen sind ausführbare Blöcke, die Parameter entgegennehmen und Werte zurückgeben können.

function summe(a, b) {  
    return a + b;  
}  
console.log(summe(2, 3)); // 5  

function summe(a, b) {  
    return a + b;  
}  
console.log(summe(2, 3)); // 5  

Weitere Referenztypen ( Date, RegExp, etc. )
JavaScript bietet eingebaute Objekttypen wie Date für Datumsoperationen oder RegExp für reguläre Ausdrücke.

let heute = new Date();  
let regex = /[A-Z]/g;  

let heute = new Date();  
let regex = /[A-Z]/g;  

Dynamische Typisierung & Typumwandlung

Da JavaScript dynamisch typisiert ist, kann sich der Typ einer Variable ändern.

Implizite Typumwandlung (Coercion)
JavaScript versucht automatisch, Typen anzupassen, was zu überraschendem Verhalten führen kann.

console.log("5" + 3); // "53" (String-Konkatenation)  
console.log("5" - 3); // 2 (Automatische Umwandlung in Number)  

console.log("5" + 3); // "53" (String-Konkatenation)  
console.log("5" - 3); // 2 (Automatische Umwandlung in Number)  

Explizite Typumwandlung
Man kann Typen gezielt umwandeln:

let zahlAlsString = String(42); // "42"  
let stringAlsZahl = Number("42"); // 42  
let boolAlsZahl = Number(true); // 1  

let zahlAlsString = String(42); // "42"  
let stringAlsZahl = Number("42"); // 42  
let boolAlsZahl = Number(true); // 1  

Prüfung von Datentypen ( typeof & instanceof )

typeof gibt den Typ einer Variable zurück (nicht für null oder Objekte zuverlässig).
instanceof prüft, ob ein Objekt zu einer bestimmten Klasse gehört.

console.log(typeof 42); // "number"  
console.log(typeof []); // "object" (Problem!)  
console.log([] instanceof Array); // true  

console.log(typeof 42); // "number"  
console.log(typeof []); // "object" (Problem!)  
console.log([] instanceof Array); // true  

Essenziell

Das Verständnis der JavaScript-Datentypen ist essenziell, um robusten Code zu schreiben. Während primitive Typen einfach und unveränderlich sind, arbeiten Referenztypen mit Speicheradressen, was bei Manipulationen beachtet werden muss. Durch bewusste Typumwandlung und strikte Vergleiche lassen sich viele Fehler vermeiden.