Datentypen in JavaScript – Welche gibt es und wie unterscheiden sie sich

Datentypen in JavaScript: Alles über Struktur, Zweck und Unterschiede

Das ist der zweite Artikel aus der Serie Daten & Algorithmen. In diesem dreht sich alles um die Themen Datentypen und Datenformate in JavaScript.

JavaScript lebt von seiner Dynamik. Es ist eine Sprache, in der man flexibel mit Daten arbeiten kann, ob in Form einfacher Werte oder komplexer Strukturen. Doch diese Freiheit bringt auch Verantwortung mit sich. Wer performant und verständlich programmieren will, sollte die Unterschiede zwischen Datentypen und Datenformaten in JavaScript genau kennen.

In diesem Beitrag werfen wir zunächst einen Blick auf die grundlegenden Datentypen und gehen dann über zu den wichtigsten Formaten zur Strukturierung von Daten. Darüber hinaus werden wir mit diversen Vorurteilen aufräumen, uns die verschiedenen Vor- und Nachteile ansehen und uns auch um ein paar Fallstricke kümmern, die uns unterkommen können.

Typisierung in JavaScript

Wenn es um Datentypen in JavaScript geht, möchte ich am Anfang gleich mal mit einem gängigen Vorurteil aufräumen, das sich leider immer wieder hartnäckig hält. Es geht darum, dass JavaScript nicht typisiert sein soll. Diese Aussage ist falsch. JavaScript ist durchaus typisiert, es ist nur nicht strickt typisiert.

Ich möchte das mit einem kleinen Beispiel belegen.

console.log(42); // 42

console.log(typeof console.log); // function

console.log = 42;

console.info(typeof console.log); // number

console.log(42); // TypeError: window.runnerWindow.proxyConsole.log is not a function

console.info(console.log); // 42

In der ersten Zeile funktioniert console.log() noch wie gewohnt und wird uns in der zweiten Zeile auch als Funktion bestätigt. In der dritten Zeile wandeln wir den Wert einfach mal so in 42 um und JavaScript bestätigt uns das, indem es console.log jetzt als Zahl (number) ausweist. Wenn wir es jetzt wie in Zeile eins in seiner ursprünglichen Form benutzen möchte, wirft JavaScript einen Fehler, da console.log jetzt keine Funktion mehr ist, was es uns in der letzten Zeile noch einmal bestätigt. console.log ist jetzt eine Zahl, genauer gesagt ist es 42.

Wie wir sehen, ist JavaScript typisiert, aber nicht strickt typisiert. Wir können den Datentypen jederzeit in einen anderen ändern, was leider auch immer mal wieder unbeabsichtigt passieren und zu gemeinen Fehlern führen kann. Das ist einer der Gründe, warum Microsoft TypeScript ins Leben gerufen hat.

Datentypen in JavaScript: Grundlagen und Deklaration

Bevor wir uns mit konkreten Datenformaten wie Objekten, Arrays oder JSON beschäftigen, ist es wichtig, ein solides Verständnis für die Datentypen in JavaScript zu entwickeln. Denn jedes Datenformat basiert auf einem oder mehreren dieser Typen und der richtige Umgang damit beginnt schon bei der Deklaration.

Die wichtigsten Datentypen

In JavaScript existieren insgesamt acht grundlegende Datentypen. Sie lassen sich grob in zwei Kategorien einteilen: primitive Datentypen und Referenztypen (auch “komplexe Datentypen” genannt). Diese Unterscheidung ist zentral, da sie Auswirkungen auf Speicherung, Vergleich und Veränderung von Daten hat.

Primitive Datentypen

Ein primitiver Datentyp in JavaScript ist ein einfacher, nicht-referenzierter Wert, der direkt im Speicher gespeichert wird und nicht veränderbar ist.

immutable

Ein primitiver Wert ist immutable, d. h. er kann nicht intern verändert werden. Wenn wir ihn ändern, ersetzen wir den ganzen Wert, nicht einen Teil davon.

let str = "Code";
console.log(str); // Code

str[0] = "M";     // ❌ Keine Wirkung
console.log(str); // Code

str = "Mode";     // ✅ Neue Zeichenkette wird erstellt
console.log(str); // Mode

Der ursprüngliche String "Code" bleibt unangetastet. Der neue String "Mode" wird separat erzeugt und str zeigt jetzt darauf.

By Value

Der zugewiesene Wert hängt direkt an der Variablen. Bei der Zuweisung des Wertes an eine neue Variable oder bei der Übergabe an eine Funktion wird eine Kopie des Werts erstellt.

let x = 10;
let y = x;

y += 5;

console.log(x); // 10
console.log(y); // 15

Änderungen an y beeinflussen x nicht, weil x’s Wert kopiert wurde, nicht referenziert.

Liste der primitiven Datentypen in JS

Number

Zum Datentpy Number zählen alle Ganzzahlen und Fließkommazahlen aber auch die Werte NaN (not a number) und Infinity (unendlich).

let zahl = 42;
let pi = 3.14;
let unendlich = Infinity;
let keineZahl = NaN;

String

Zum Datentyp String zählen Zeichenketten. Diese können in folgenden Formen geschrieben werden ', " oder ` geschrieben werden. Letztere nennt man einen Templateliteral. Dieser kann auch Variablen enthalten.

let name = "Jake";
let message = 'Hello, Hacker!';
let greeting = `Hello ${name}`;

Boolean

Der Datentyp Boolean ist auf die Werte true und false beschränkt.

let istHacker = true;
let hatZugriff = false;

undefined

Der Datentyp undefined ist ein automatischer Wert, der für eine nicht initialisierte Variable vergeben wird. Er könnte allerdings auch händisch vergeben werden, was in der Praxis jedoch kaum zum Einsatz kommt. Da würde eher auf den nächsten Datentypen null zurückgegriffen werden.

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

let secret = undefined;
console.log(secret); // undefined

null

Der Datentyp null zeigt, dass die Variable keinen Wert hat. Im Gegensatz zu undefined ist er allerdings absichtlich zugewiesen worden.

let benutzer = null;

Symbol (ES6+)

Symbol ist ein primitiver, eindeutiger und unveränderbarer Datentyp, der häufig als einzigartiger Schlüssel für Objekte verwendet wird, um Namenskonflikte zu vermeiden.

const geheimKey = Symbol("id");

BigInt (ES2020)

BigInt ist ein primitiver Datentyp in JavaScript, der verwendet wird, um ganze Zahlen beliebiger Größe darzustellen, die über das Limit von Number hinausgehen.

const megaZahl = 9007199254740991n;

Alle primitiven Werte werden nach Wert verglichen (nicht nach Speicheradresse) und nicht verändert, sondern bei Änderungen ersetzt.

Referenztypen

Referenztypen sind veränderbare Objekte, die durch ihre Speicherreferenz identifiziert werden. Das bedeutet: Zwei identische Objekte gelten als ungleich, wenn sie nicht dieselbe Referenz haben.

Klar – hier kommen jetzt auch die drei JavaScript-Klassiker Objekte, Arrays und Funktionen – jeweils kompakt erklärt, mit kommentierten Codebeispielen und dem Fokus auf Struktur, Zweck und typischem Einsatz. Damit hast du dann eine vollständige Darstellung der wichtigsten Referenztypen in JavaScript.

Hier eine Auswahl der vielleicht wichtigsten Referenzdatentypen in JavaScript:

Object

Ein Objekt ist die grundlegendste strukturierte Datenform in JavaScript. Es besteht aus Eigenschaften, die jeweils einen Schlüssel (key) und einen Wert (value) haben.

const user = {
  name: "Lea",
  age: 29,
  isAdmin: true
};

console.log(user.name);       // "Lea"
console.log(user["age"]);     // 29

user.age = 30;                // Eigenschaft ändern
user.country = "Germany";     // Neue Eigenschaft hinzufügen

delete user.isAdmin;          // Eigenschaft löschen

Objekte sind ideal, um strukturierte Daten darzustellen. Sie sind dynamisch, leicht zu erweitern und lassen sich leicht in das JSON Dateiformat umwandeln.

Array

Ein Array speichert mehrere Werte in einer bestimmten Reihenfolge. Jeder Wert ist über einen Index zugänglich, beginnend bei 0.

const fruits = ["Apfel", "Banane", "Kirsche"];

console.log(fruits[0]);      // "Apfel"
console.log(fruits.length);  // 3

fruits.push("Orange");       // Element hinzufügen
fruits.splice(1, 1);         // "Banane" entfernen

Arrays verfügen über viele eingebaute Methoden wie .map(), .filter(), .reduce() – ideal zum Verarbeiten von Datenmengen.

Arrays sind perfekt für Listen, Reihenfolgen oder gruppierte Daten. Sie bilden die Grundlage für Tabellen, API-Antworten oder DOM-Elemente.

Function

Funktionen sind wiederverwendbare Codeblöcke. Sie können Parameter entgegennehmen, Berechnungen durchführen und Werte zurückgeben.

function greet(name) {
  return `Hallo, ${name}!`;
}

console.log(greet("Lea"));  // "Hallo, Lea!"

Du kannst auch Funktionen als Variablen speichern:

const multiply = (a, b) => a * b;
console.log(multiply(3, 4)); // 12

Funktionen sind zentrale Bausteine jeder Anwendung. Sie ermöglichen Modularität, Wiederverwendbarkeit und Abstraktion.

class

JavaScript unterstützt seit ES6 das Arbeiten mit Klassen zur Modellierung von Objekten mit Verhalten (Methoden) und Zustand (Eigenschaften).

class Person {
  constructor(name, age) {
    this.name = name;
    this.age = age;
  }

  greet() {
    return `Hallo, mein Name ist ${this.name} und ich bin ${this.age} Jahre alt.`;
  }
}

const lea = new Person("Lea", 29);
console.log(lea.greet()); 
// Ausgabe: Hallo, mein Name ist Lea und ich bin 29 Jahre alt.

Klassen bieten Struktur für komplexe Datenmodelle. Sie sind besonders hilfreich in größeren Anwendungen oder bei objektorientierten Architekturen.

Map

Maps sind moderne Alternativen zu Objekten, wenn du Schlüssel-Wert-Zuordnungen brauchst, bei denen beliebige Datentypen als Schlüssel verwendet werden können.

const userRoles = new Map();
userRoles.set("Lea", "Admin");
userRoles.set("Jan", "Editor");

console.log(userRoles.get("Lea")); 
// Ausgabe: "Admin"

console.log(userRoles.size); 
// Ausgabe: 2

Anders als bei Objekten bleibt bei Maps die Einfügereihenfolge erhalten, und selbst Objekte oder Funktionen können als Schlüssel dienen.

Set

Sets speichern nur eindeutige Werte und ignorieren automatisch Duplikate.

const tags = new Set();
tags.add("JavaScript");
tags.add("WebDev");
tags.add("JavaScript"); // wird ignoriert

console.log(tags.has("JavaScript")); 
// Ausgabe: true

console.log(tags.size); 
// Ausgabe: 2

Perfekt zum Filtern von Duplikaten oder zur effizienten Zugehörigkeitsprüfung. Set kann in vielen Fällen komplexe Array-Filterlogik ersetzen.

Date

Date ist ein eingebautes Objekt zur Arbeit mit Zeitangaben.

const now = new Date();
console.log(now.toISOString()); 
// Ausgabe: z. B. "2025-04-19T14:07:23.456Z"

const birthday = new Date("1995-06-15");
console.log(birthday.getFullYear()); 
// Ausgabe: 1995

Das Date-Objekt bietet zahlreiche Methoden zum Rechnen, Vergleichen und Formatieren von Datum/Zeit. Es eignet sich für die Erstellung von Kalendern bis zu Zeitstempeln.

Vergleiche man zwei Objekte

const a = { value: 1 };
const b = { value: 1 };

console.log(a === b); // false
console.log(JSON.stringify(a) === JSON.stringify(b)); // true

Beide Objekte haben zwar denselben Inhalt, aber sie zeigen auf unterschiedliche Speicherbereiche. Sie sind daher nicht gleich. Um sie vergleichen zu können, müssen wir sie zuerst in Strings verwandeln. Diese Strings sind dann vergleichbar.

By Reference

Der Variablen wird nur eine Refferenz auf den tatsächlichen Wert zugewiesen. Bei der Zuweisung des Wertes an eine neue Variable oder bei der Übergabe an eine Funktion wird ebenfalls nur eine Refferenz übergeben.

const a = { value: 1 };
console.log(a) // { value: 1 }

const b = a;
console.log(b) // { value: 1 }

b = { value: 2 };
console.log(b) // { value: 2 }

console.log(a) // { value: 2 }

Im Beispiel wird der Wert von Variable a einem neuen Variable b zugewiesen. Ändere ich jetzt den internen Wert von b, ändert sich automatisch auch der von a. Der Grund hierfür ist, dass hier nur eine Refferenz zugewiesen wurde.

Wenn wir das umgehen wollen, müssen wir eine Kopie von a erzeugen, der wir dann b zuweise. Wenn wir dann den inneren Wert von b ändere, bleibt a unverändert.

const a = { value: 1 };
console.log(a) // { value: 1 }

const b = Object.assign({}, a);
console.log(b) // { value: 1 }

b.value = 2;
console.log(b) // { value: 2 }

console.log(a) // { value: 1 }

var, let und const: Variablendeklaration in der Praxis

In JavaScript stehen drei Möglichkeiten zur Verfügung, um eine Variable zu deklarieren: var, let und const. Alle drei sind für primitive und Referenztypen gleichermaßen nutzbar, unterscheiden sich jedoch in Sichtbarkeit, Gültigkeitsbereich und Änderbarkeit.

var)

var name = "Alex";

In einer Funktion vwerwendet ist var im gesamten Bereich (scope) einer Funktion gültig. Man spricht hier auch von function scope. Es wird automatisch am Anfang der Funktion bekanntgemacht (gehoistet) und kann mehrfach deklariert (geändert) werden.

function myFunc() {
  console.log(name); // undefined
  
  var name = "Tim";
  console.log(name); // Tim
}

In modernen Projekten sollte var nicht mehr verwendet werden, da es leicht zu unerwartetem Verhalten führen kann. Das gilt in der Regel aber nur für Entwickler:innen, die ein solches Verhalten aus anderen Programmiersprachen nicht kennen.

let

let count = 5;

let ist lediglich innerhalb des Codeblocks, also innerhalb eines Bereiches, der durch zwei geschweifte Klammern {} begrenzt wird, gülgit. Er kann verändert, aber nicht erneut deklariert werden und ist ideal für veränderbare Variablen.

function myFunc(language) {
  let name = "Andreas";
  console.log(name); // Andreas
  
  if (language === 'italian') {
    let name = "Andrea";
    console.log(name); // Andrea
  }
  console.log(name) // Andreas
}

myFunc('italian');

const

const name = "Andreas";

name = "Andrea"; // TypeError: : Assignment to constant variable.

Die Gültigkeit von const liegt ebenfall nur in dem Block vor, in dem es deklariert wurde. Const muss im Gegensatz zu let allerdings sofort initialisiert werden, da es zumindest als primitiver Datentyp nicht mehr verändert werden kann. Bei Referenztypen ist das etwas komplexer. Da ist die Referenz ansich konstant, nicht aber deren Inhalt.

function myFunc(language) {
  const name = "Andreas";
  console.log(name); // Andreas
  
  if (language === 'italian') {
    const name = "Andrea";
    console.log(name); // Andrea
  }
  
  name = "Otto"; // TypeError: Assignment to constant variable.
}

myFunc('italian');

Wichtig: const schützt nicht vor Änderungen des Inhalts bei Referenztypen!

const user = { name: "Lea" };

user.name = "Toni"; // erlaubt!

user = { name: "Alex" }; // TypeError: : Assignment to constant variable.

Bei primitiven Datentypen wie string oder number ist der Unterschied nicht sichtbar, da diese ohnehin unveränderlich sind. Aber bei Referenztypen wie Objekten oder Arrays ist const kein Schutz vor Mutation, sondern nur vor Neu-Zuweisung.

Primitive vs. Referenztypen: Unterschiede im Detail

Ein Beispiel zur Veranschaulichung:

let a = 10;
let b = a;
b = 20;
console.log(a); // 10

let obj1 = { name: "Lea" };
let obj2 = obj1;
obj2.name = "Alex";
console.log(obj1.name); // "Alex"

Bei primitiven Werten wird b von a kopiert – bei Objekten zeigt obj2 auf dasselbe Objekt wie obj1.

Warum das alles wichtig ist

Diese Unterschiede sind zentral für das Verständnis von Datenverarbeitung in JavaScript. Wer etwa ein Objekt in einer Funktion manipuliert, verändert unter Umständen auch das Original. Wer mit const arbeitet, darf nicht annehmen, dass der Inhalt gesperrt ist. Und wer JSON speichert, muss wissen, dass Funktionen oder undefined darin nicht enthalten sein werden.

Alle später behandelten Datenformate – etwa Arrays, Maps, Sets, JSON – basieren auf genau diesen Prinzipien. Wer sie kennt, schreibt sicheren, verständlichen und wartbaren Code.

Fazit: Von Datentypen zu strukturierten Formaten

Datentypen sind die Basis allen Verständnisses von Daten. Primitive Werte sind schnell, klar und ideal für einfache Informationen. Für alles darüber hinaus bieten Objekte, Arrays, Maps und Sets flexible und leistungsfähige Werkzeuge.

Ob Du Nutzer:innen-Daten verwaltest, API-Antworten verarbeitest oder eigene Datenmodelle entwickelst: Die Wahl des richtigen Formats ist entscheidend für Verständlichkeit, Effizienz und Wartbarkeit.

FAQ: Datentypen in JavaScript

Was ist der Unterschied zwischen primitiven Datentypen und Referenztypen in JavaScript?

Primitiven Datentypen (wie string, number, boolean, undefined, null, symbol, bigint) sind unveränderbare Werte, die direkt im Speicher liegen. Wenn du einen primitiven Wert einer Variablen zuweist, wird eine Kopie des Wertes gespeichert.

Beispiel:

let a = 5;
let b = a;

b = 10;
console.log(a); // 5

Referenztypen (z. B. object, array, function, map, set) verweisen hingegen auf Speicheradressen im Heap. Zwei Variablen können dieselbe Referenz teilen. Änderungen an einem Objekt wirken sich auf beide aus.

const obj1 = { name: "Lea" };
const obj2 = obj1;

obj2.name = "Toni";
console.log(obj1.name); // "Toni"

Wie prüft man den Datentyp einer Variablen in JavaScript?

Der einfachste Weg ist die Verwendung von typeof. Es funktioniert zuverlässig für primitive Datentypen.

typeof "Hallo";     // "string"
typeof 42;          // "number"
typeof true;        // "boolean"

Für Arrays und null ist typeof allerdings ungenau.

typeof [];          // "object"
typeof null;        // "object"

Hier hilft es einen anderen Weg zu gehen, der zu einem genaueren Ergebnis führt.

Array.isArray([]);  // true

Oder ein präziserer Check mit Object.prototype.toString.call():

Object.prototype.toString.call([]); // "[object Array]"

3. Was passiert, wenn ich einen primitiven Wert mit einem Objekt vergleiche?

Wenn du einen primitiven Wert (z. B. 5) mit einem Objekt (z. B. {}) vergleichst, passiert eine implizite Typumwandlung, um beide Werte vergleichbar zu machen.

Beispiel:

console.log(5 == "5");    // true (lose Gleichheit, Konvertierung)
console.log(5 === "5");   // false (strikte Gleichheit, kein Typwechsel)

Bei striktem Vergleich (===) wird kein Typ konvertiert, was den Vergleich sicherer macht. Verwende deshalb bevorzugt === und !==.

Kann ich mit const auch veränderbare Daten speichern?

Ja, und das ist ein häufiger Irrtum: const bedeutet, dass die Referenz nicht neu zugewiesen werden darf – aber der Inhalt eines Objekts oder Arrays kann sehr wohl verändert werden.

const user = { name: "Lea" };
user.name = "Toni";       // erlaubt
user = { name: "Alex" };  // Fehler!

Für primitive Werte ist das Verhalten wie erwartet (nicht änderbar). Für Referenztypen musst du auf andere Weise sicherstellen, dass Inhalte nicht verändert werden – z. B. mit Object.freeze().

Welche Typen sind serialisierbar mit JSON.stringify()?

JSON.stringify() konvertiert Daten in einen JSON-kompatiblen String – allerdings nicht alle Datentypen:

✔️ Erlaubt:

• Objekte
• Arrays
• Strings
• Zahlen
• Booleans
• null

🚫 Nicht erlaubt oder ignoriert:

• Funktionen
• undefined
• Symbole
• Zirkuläre Referenzen

Beispiel:

const data = {
  name: "Lea",
  greet: () => "Hi",
  age: undefined
};
console.log(JSON.stringify(data)); 
// => {"name":"Lea"}

Was bedeutet “immutabel” bei primitiven Datentypen?

Ein primitiver Wert kann nicht verändert werden – wenn du ihn „veränderst“, erzeugst du in Wahrheit einen neuen Wert. Das bedeutet:

let str = "Hallo";
str[0] = "X";
console.log(str); // "Hallo"

Strings sind nicht änderbar – Operationen wie .toUpperCase() oder .slice() erzeugen neue Strings, das Original bleibt gleich.

Bei Referenztypen kann der Inhalt verändert werden, ohne die Referenz zu verändern:

const arr = [1, 2];
arr.push(3);
console.log(arr); // [1, 2, 3]

Was ist der Unterschied zwischen undefined und null?

• undefined bedeutet: Es wurde kein Wert zugewiesen.
• null bedeutet: Der Wert wurde bewusst auf „leer“ gesetzt.

Beispiel:

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

let y = null;
console.log(y); // null

Beide Typen sind technisch unterschiedlich:

typeof undefined; // "undefined"
typeof null;      // "object" (ein alter Bug in JavaScript)

Wie kann ich feststellen, ob ein Wert eine Funktion ist?

Du kannst typeof verwenden:

function greet() {}
console.log(typeof greet); // "function"

Auch für Funktionen, die mit Arrow-Syntax definiert wurden:

const add = (a, b) => a + b;
console.log(typeof add); // "function"

Funktionen sind erste Bürger:innen in JavaScript – das heißt, sie können als Werte gespeichert, übergeben oder zurückgegeben werden.

Wie funktioniert das Kopieren von Referenztypen?

Wenn du ein Objekt oder Array einer neuen Variablen zuweist, kopierst du nur die Referenz, nicht den Inhalt:

const original = { name: "Lea" };
const copy = original;
copy.name = "Alex";
console.log(original.name); // "Alex"

Für eine echte Kopie (Shallow Copy) kannst du z. B. den Spread-Operator verwenden:

const copy = { ...original };

Für tiefer verschachtelte Objekte brauchst du Deep Cloning, z. B. mit structuredClone() (moderne Methode) oder einer Bibliothek wie Lodash:

const deepCopy = structuredClone(nestedObject);

Wann sollte ich let statt const verwenden – oder umgekehrt?

• Verwende const, wenn sich der Wert nicht neu zugewiesen werden soll. Das signalisiert klare Absicht und hilft beim Debugging.
• Verwende let, wenn sich der Wert ändern kann – z. B. in Schleifen oder bei Zuständen.

Beispiel:

const baseUrl = "https://api.example.com";
let counter = 0;
counter++;

Vermeide var in modernem JavaScript – es führt zu unerwartetem Verhalten durch Hoisting und fehlenden Blockscope.

Buy me a coffee

Wenn Dir meine Beiträge gefallen und sie Dir bei Deiner Arbeit helfen, würde ich mich über einen “Kaffee” und ein paar nette Worte von Dir freuen.

Buy me a coffee

Weiterführende externe Links

• ChartJS - einfache und flexible JavaScript-Diagrammbibliothek für das moderne Web
• D3 - die JavaScript-Bibliothek für maßgeschneiderte Datenvisualisierung
• Lodash - eine moderne JavaScript-Dienstprogrammbibliothek
• Tensorflow JS - eine Bibliothek für maschinelles Lernen in JavaScript
• Underscore - eine JavaScript-Bibliothek mit nützlicher Helfern für die funktionale Programmierung