WissensdatenbankPrüfungszentrum
DEDeutsch
Sprache wählen13

CKTIS / JavaScript

Array-Länge und Indizierung in JavaScript

`length` legt die Indexgrenze eines Arrays fest, zählt aber keine Elemente. Indexzuweisungen können diese Grenze verschieben, und eine Lücke ist nicht dasselbe wie `undefined`.

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

Syntax

a.length; a[i]; a[i] = value; a.length = n; delete a[i]; Object.hasOwn(a, i); a.at(i);

Array-Indizes beginnen bei null. a.length ist eine eigene Eigenschaft, standardmäßig schreibbar, aber nicht konfigurierbar. Ihr Wert ist eine ganze Zahl von 0 bis 2 ** 32 - 1. Er ist die exklusive Obergrenze für die Indizes eigener Elemente, nicht deren Anzahl. Array.length hingegen gibt die Anzahl der erwarteten Parameter der Konstruktorfunktion an, nicht die Länge eines Arrays.

Eckige Klammern greifen auf Eigenschaften zu: a[1] und a["1"] verwenden denselben Schlüssel. Array-Indizes sind die kanonischen Dezimalschreibweisen der ganzen Zahlen von 0 bis 2 ** 32 - 2. Schlüssel wie "01", "-1" und "4294967295" sind keine Array-Indizes und ändern die Länge nicht. a[-1] sucht die Eigenschaft "-1"; a.at(-1) liest die letzte Position eines nicht leeren Arrays. Liegt der berechnete Index außerhalb des Bereichs, gibt at() ohne Eigenschaftszugriff undefined zurück.

Ein eigenes Element bei i >= a.length erhöht die Länge auf i + 1. Übersprungene Positionen bleiben Lücken. Eine Lücke hat keine eigene Eigenschaft; beim Lesen erhält man undefined, sofern kein Wert geerbt wird. Object.hasOwn(a, i) unterscheidet eine Lücke von einem eigenen Element mit dem Wert undefined. Ein erfolgreiches delete a[i] entfernt ein Element, ohne das Array zu verkürzen.

Eine größere length fügt Lücken hinzu; eine kleinere löscht eigene Elemente an oder oberhalb der neuen Grenze. Ist length schreibbar, löst die Zuweisung eines Number-Werts, der nicht ganzzahlig ist oder außerhalb des zulässigen Bereichs liegt, RangeError aus. Bei der Zuweisung eines BigInt-Werts tritt dagegen schon bei der Konvertierung, noch vor der Bereichsprüfung, ein TypeError auf. Ein nicht konfigurierbares Element kann die Kürzung blockieren: Elemente mit höheren Indizes können bereits gelöscht sein, und die Länge bleibt beim blockierenden Index plus eins stehen. Im Strict Mode löst diese fehlgeschlagene Zuweisung TypeError aus.

Beispiele

{
  const a = ["A"];
  a[3] = "D";
  a[2] = undefined;
  a[-1] = "tag";

  console.log(`length: ${a.length}`);
  console.log(`1: ${a[1]}, own: ${Object.hasOwn(a, 1)}`);
  console.log(`2: ${a[2]}, own: ${Object.hasOwn(a, 2)}`);
  console.log(`[-1]: ${a[-1]}, at(-1): ${a.at(-1)}`);

  a.length = 1;
  a.length = 4;
  console.log(`length: ${a.length}, own 3: ${Object.hasOwn(a, 3)}, [-1]: ${a[-1]}`);
}

Ergebnis

length: 4
1: undefined, own: false
2: undefined, own: true
[-1]: tag, at(-1): D
length: 4, own 3: false, [-1]: tag

An `1` und `2` liest man `undefined`, aber nur `2` ist ein eigenes Element. Erneutes Verlängern stellt Element `3` nicht wieder her; die Eigenschaft `"-1"` bleibt erhalten.

Zugehörige Lektionen

  • JavaScript · Lektion 41 · Fortgeschritten · Version: 4

Quellen