null — Keyword · JavaScript-Referenz

Signatur

null

Beschreibung

null ist ein Literal und einer der sieben primitiven Werte in JavaScript. Es zeigt an, dass eine Variable oder Eigenschaft absichtlich keinen Wert bzw. kein Objekt enthält. Anders als ein nicht deklarierter Bezeichner ist null ein echter, zuweisbarer Wert. Da es sich um ein reserviertes Wort handelt, kann es nicht als Variablenname verwendet werden.

Der Unterschied zu undefined ist vor allem ein inhaltlicher: undefined bedeutet „wurde nie gesetzt“ (z. B. nicht initialisierte Variablen, fehlende Parameter, nicht vorhandene Eigenschaften), während null bedeutet „wurde bewusst auf leer gesetzt“. Viele APIs geben null zurück, wenn nichts gefunden wurde, etwa document.querySelector(), String.prototype.match() oder localStorage.getItem().

Typische Einsatzgebiete sind das Zurücksetzen von Referenzen (z. B. damit der Garbage Collector ein Objekt freigeben kann), Platzhalter für später zu ladende Daten, das Kennzeichnen leerer Felder in JSON sowie die Erzeugung prototypfreier Objekte mit Object.create(null). null steht außerdem am Ende jeder Prototypkette.

Zum Prüfen sollte man value === null verwenden. Möchte man null und undefined gemeinsam behandeln, eignen sich value == null, der Nullish-Coalescing-Operator ?? und die optionale Verkettung ?..

Rückgabewert

Typ

null

Beschreibung

Der primitive Wert null. Achtung: typeof null ergibt aus historischen Gründen "object".

Beispiele

Grundverhalten und Vergleiche

let user = null; // bewusst noch kein Benutzer

console.log(user);                 // null
console.log(typeof user);          // "object" (historischer Fehler)
console.log(user === null);        // true
console.log(user === undefined);   // false
console.log(user == undefined);    // true (lose Gleichheit)
console.log(null + 1);             // 1 (null wird zu 0)
console.log(Boolean(null));        // false

null object true false true 1 false

API-Rückgaben mit ?? und ?. absichern

// localStorage.getItem liefert null, wenn der Schlüssel fehlt
const theme = localStorage.getItem('theme') ?? 'light';
console.log(theme);

// querySelector liefert null, wenn kein Element passt
const title = document.querySelector('#nicht-vorhanden');
console.log(title?.textContent ?? 'Kein Titel gefunden');

// match liefert null bei keinem Treffer
const m = 'abc'.match(/\d+/);
console.log(m === null ? 'Keine Zahl' : m[0]);

light Kein Titel gefunden Keine Zahl

Referenz freigeben und leere Felder in JSON

class ImageCache {
  #data = new Map();
  #current = null;

  load(url) {
    this.#current = { url, loadedAt: Date.now() };
    this.#data.set(url, this.#current);
  }

  clear() {
    this.#data.clear();
    this.#current = null; // Referenz für den Garbage Collector freigeben
  }

  get current() { return this.#current; }
}

const cache = new ImageCache();
cache.load('/logo.png');
cache.clear();
console.log(cache.current);

// null bleibt in JSON erhalten, undefined nicht
console.log(JSON.stringify({ a: null, b: undefined }));

null {"a":null}

Prototypfreies Objekt als Wörterbuch

const dict = Object.create(null);
dict.toString = 'kein Konflikt';

console.log(Object.getPrototypeOf(dict)); // null
console.log('hasOwnProperty' in dict);    // false
console.log(Object.getPrototypeOf(Object.prototype)); // null – Ende der Kette

null false null

// Wichtig · Fallstricke

typeof null === "object": ein seit der ersten JavaScript-Version bestehender Fehler, der aus Kompatibilitätsgründen nie behoben wurde. Zur Objektprüfung daher value !== null && typeof value === 'object' verwenden.
Standardparameter greifen nicht bei null: function f(x = 5) {} – f(undefined) ergibt 5, f(null) ergibt null. Dasselbe gilt für Standardwerte bei der Destrukturierung.
Numerische Umwandlung: null wird zu 0 (null + 1 === 1, null >= 0 ist true), aber null == 0 ist false. undefined wird dagegen zu NaN.
|| vs. ??: || ersetzt auch 0, '' und false; ?? reagiert nur auf null und undefined.
Laufzeitfehler: Eigenschaftszugriffe auf null werfen einen TypeError („Cannot read properties of null“). Mit ?. absichern.
null ist ein Literal, keine Eigenschaft des globalen Objekts (im Gegensatz zu undefined) und kann weder überschrieben noch als Bezeichner genutzt werden.
In TypeScript wird null mit strictNullChecks zu einem eigenen Typ, der explizit (z. B. string | null) erlaubt werden muss.

Siehe auch

undefined ?? (Nullish Coalescing) ?. (Optional Chaining) typeof Object.create() Objekt-Initialisierer