Array: length — Eigenschaft · JavaScript-Referenz

Signatur

Array.prototype.length

Beschreibung

Die Eigenschaft length ist eine eigene Daten-Eigenschaft jeder Array-Instanz, also kein Getter auf dem Prototyp. Ihr Wert ist eine nicht-negative Ganzzahl kleiner als 2³² und ist immer um eins größer als der höchste belegte Index. Damit zählt length die Plätze, nicht die tatsächlich vorhandenen Elemente: Bei dünn besetzten Arrays (Arrays mit Lücken) kann length größer sein als die Zahl der wirklich gesetzten Werte.

length wird automatisch aktualisiert, sobald du ein Element an einem Index ≥ length einfügst, z. B. über push() oder arr[arr.length] = x. Umgekehrt kannst du length auch selbst setzen: Ein kleinerer Wert schneidet das Array ab und löscht alle Elemente ab dem neuen Ende, ein größerer Wert verlängert das Array um leere Plätze (empty slots), ohne dabei tatsächlich Werte anzulegen.

Die Eigenschaftsattribute sind: writable: true, enumerable: false, configurable: false. Deshalb taucht length nicht in for...in-Schleifen oder Object.keys() auf und lässt sich nicht mit delete entfernen.

Typische Anwendungen sind Schleifengrenzen, das Prüfen auf leere Arrays, der Zugriff auf das letzte Element (arr[arr.length - 1], heute alternativ arr.at(-1)) sowie das schnelle Leeren eines Arrays mit arr.length = 0.

Parameter

Name	Typ	Default	Beschreibung
$(Zuweisungswert)	number		Nur beim Setzen: neue Länge als nicht-negative Ganzzahl im Bereich `0` bis `2**32 - 1`. Andere Werte führen zu einem `RangeError`.

Rückgabewert

Typ

number

Beschreibung

Eine nicht-negative Ganzzahl kleiner als 2³²: höchster Index plus eins. Bei leeren Arrays 0.

Beispiele

Länge lesen und über ein Array iterieren

const aufgaben = ['Einkaufen', 'Code-Review', 'Deployment'];

console.log(aufgaben.length);

for (let i = 0; i < aufgaben.length; i++) {
  console.log(`${i + 1}/${aufgaben.length}: ${aufgaben[i]}`);
}

// Letztes Element
console.log(aufgaben[aufgaben.length - 1]);

3 1/3: Einkaufen 2/3: Code-Review 3/3: Deployment Deployment

Array kürzen oder komplett leeren

const log = ['a', 'b', 'c', 'd', 'e'];

// Nur die ersten drei Einträge behalten
log.length = 3;
console.log(log);

// Array leeren – alle Referenzen sehen das leere Array
const referenz = log;
log.length = 0;
console.log(referenz, referenz.length);

[ 'a', 'b', 'c' ] [] 0

Lücken: length zählt Plätze, nicht Elemente

const werte = [10, 20];
werte[5] = 60;

console.log(werte.length);            // höchster Index + 1
console.log(werte);                   // leere Plätze dazwischen

// Tatsächlich gesetzte Elemente zählen
const belegt = werte.filter(() => true).length;
console.log(belegt);

// Verlängern erzeugt nur leere Plätze
const leer = [];
leer.length = 3;
console.log(leer, 0 in leer);

6 [ 10, 20, <3 empty items>, 60 ] 3 [ <3 empty items> ] false

Ungültige Länge und Leere-Prüfung

const istLeer = (arr) => Array.isArray(arr) && arr.length === 0;
console.log(istLeer([]), istLeer([0]));

try {
  const arr = [];
  arr.length = -1;
} catch (err) {
  console.log(err.name);
}

true false RangeError

// Wichtig · Fallstricke

Lücken: length entspricht nicht zwingend der Anzahl echter Elemente. arr[100] = 'x' auf einem leeren Array ergibt length === 101. Methoden wie forEach() oder map() überspringen leere Plätze, eine klassische for-Schleife liefert dort undefined.
Destruktives Kürzen: Wenn du length verkleinerst, werden die Elemente unwiderruflich gelöscht, und zwar für alle Referenzen auf dasselbe Array. Brauchst du eine Kopie, nimm stattdessen slice().
RangeError: Negative Zahlen, Nicht-Ganzzahlen (z. B. 1.5) oder Werte ≥ 2³² lösen beim Setzen einen RangeError aus.
Nicht beschreibbar gemacht: Bei eingefrorenen Arrays (Object.freeze()) oder mit Object.defineProperty(arr, 'length', { writable: false }) scheitern push() und ähnliche Methoden mit einem TypeError. Direkte Zuweisungen werden im Sloppy Mode stillschweigend ignoriert und werfen im Strict Mode einen Fehler.
Performance: Das Lesen von length kostet in modernen Engines praktisch nichts. Das Zwischenspeichern in Schleifen bringt kaum noch etwas. Sehr große dünn besetzte Arrays können Engines aber in einen langsameren „Dictionary-Modus“ zwingen.
Array-ähnliche Objekte (arguments, NodeList, Strings) haben ebenfalls eine length-Eigenschaft, die sich aber teilweise anders verhält: Bei Strings ist sie schreibgeschützt, und das Setzen kürzt dort nichts.

Siehe auch

Array.prototype.push() Array.prototype.at() Array.prototype.splice() Array.prototype.slice() String: length Array