WissensdatenbankPrüfungszentrum
DEDeutsch
Sprache wählen13

CKTIS / JavaScript

`length`: die beschreibbare Eigenschaft eines Arrays

`arr.length` liefert die Länge eines Arrays. Eine Zuweisung kann dasselbe Array kürzen oder verlängern, ohne dabei neue Elemente anzulegen.

Version: ECMAScript 2024 and the current web platform; runtime support varies

Syntax

arr.length
arr.length = newLength

arr.length ist eine eigene Dateneigenschaft einer Array-Instanz, nicht die Eigenschaft length des Konstruktors Array. Sie ist anfangs beschreibbar, aber weder aufzählbar noch konfigurierbar. Ihr Wert ist größer als jeder eigene Array-Index und kann die Anzahl der vorhandenen Elemente übersteigen.

Beim Verringern von length werden eigene Elemente ab der neuen Länge gelöscht. arr.length = 0 leert ein gewöhnliches Array direkt: Die Änderung ist über alle Referenzen auf dasselbe Array sichtbar. Eine größere Länge lässt Lücken entstehen, keine Elemente mit dem Wert undefined, und stellt gelöschte Elemente nicht wieder her. Wird ein Element an einem gültigen Array-Index i ab der bisherigen Länge angelegt, steigt die Länge auf i + 1.

Die Länge ist eine ganze Zahl vom Typ Number zwischen 0 und 2 ** 32 - 1 einschließlich. Beim Schreiben auf eine beschreibbare length wird der Wert konvertiert: "3" wird beispielsweise als 3 akzeptiert, aber 2.5, -1 und 2 ** 32 lösen einen RangeError aus. Die Konvertierung von Symbol oder BigInt löst stattdessen einen TypeError aus.

Trifft das Kürzen auf ein nicht konfigurierbares Element, endet es an dessen Index. Die Länge wird auf diesen Index plus eins gesetzt; bereits gelöschte Elemente mit höheren Indizes bleiben gelöscht. Mit writable: false lässt sich length dauerhaft schreibschützen. Das verhindert Zuweisungen an length und das Hinzufügen von Elementen, die das Array verlängern würden, aber nicht jede Änderung an Elementen. In beiden Fällen löst eine fehlgeschlagene Zuweisung im Strict Mode einen TypeError aus; außerhalb des Strict Mode wird kein Fehler ausgelöst.

Beispiele

(() => {
  "use strict";
  const arr = ["a", "b", "c"];
  const alias = arr;

  arr.length = 1;
  console.log(`${alias.length}: ${alias.join(",")}`);

  arr.length = 3;
  arr[2] = undefined;
  console.log(`${arr.length}: ${Object.hasOwn(arr, 1)}, ${Object.hasOwn(arr, 2)}`);

  arr[4] = "e";
  console.log(`${arr.length}: ${arr[4]}`);

  try {
    arr.length = 2.5;
  } catch (error) {
    console.log(`${error.name}: ${arr.length}`);
  }
})();

Ergebnis

1: a
3: false, true
5: e
RangeError: 5

Über `alias` ist sichtbar, dass dasselbe Array kürzer wird. Nach dem Verlängern unterscheidet `Object.hasOwn` die Lücke an Index `1` vom ausdrücklich gesetzten Wert `undefined` an Index `2`. Der Schreibzugriff an Index `4` erhöht die Länge auf `5`; der abgelehnte Wert `2.5` ändert sie nicht.

Zugehörige Lektionen

  • JavaScript · Lektion 20 · Fortgeschritten · Version: 4

Quellen