Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / JavaScript

Lunghezza e indicizzazione degli array in JavaScript

`length` fissa il limite degli indici di un array, ma non ne conta gli elementi. Una scrittura può spostare il limite, e una posizione vuota non equivale a `undefined`.

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

Sintassi

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

Gli indici di un array partono da zero. a.length è una proprietà propria, scrivibile per impostazione predefinita ma non configurabile. Il suo valore è un intero da 0 a 2 ** 32 - 1. È il limite superiore escluso degli indici degli elementi propri, non il loro numero. Array.length indica invece il numero di parametri attesi dalla funzione costruttrice, non la lunghezza di un array.

Le parentesi quadre accedono alle proprietà: a[1] e a["1"] usano la stessa chiave. Gli indici sono le rappresentazioni decimali canoniche degli interi da 0 a 2 ** 32 - 2. Chiavi come "01", "-1" e "4294967295" non sono indici e non modificano la lunghezza. a[-1] cerca la proprietà "-1"; a.at(-1) legge l’ultima posizione di un array non vuoto. Se l’indice calcolato è fuori dai limiti, at() restituisce undefined senza cercare quella proprietà.

Creare un elemento proprio a un indice i >= a.length porta la lunghezza a i + 1. Le posizioni saltate rimangono vuote. Una posizione vuota non ha una proprietà propria; la sua lettura restituisce undefined a meno che non venga ereditato un valore. Object.hasOwn(a, i) la distingue da un elemento proprio con valore undefined. Un delete a[i] riuscito rimuove l’elemento senza accorciare l’array.

Aumentare length aggiunge posizioni vuote; ridurla elimina gli elementi propri a partire dal nuovo limite. Se length è scrivibile, assegnarle un valore di tipo Number non intero o fuori dall’intervallo consentito genera RangeError. Assegnarle un valore di tipo BigInt genera invece TypeError durante la conversione, prima della verifica dell’intervallo. Un elemento non configurabile può bloccare il troncamento: gli elementi con indici superiori potrebbero essere già stati eliminati e la lunghezza si ferma all’indice bloccante più uno. In modalità strict, l’assegnazione fallita genera TypeError.

Esempi

{
  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]}`);
}

Risultato

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

La lettura di `1` e `2` restituisce `undefined`, ma soltanto `2` è un elemento proprio. Allungare di nuovo l’array non ripristina l’elemento `3`; la proprietà `"-1"` rimane.

Lezioni correlate

  • JavaScript · Lezione 41 · Avanzato · Versione: 4

Fonti