Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / JavaScript

Lunghezza e indicizzazione degli array in JavaScript

`length` delimita le posizioni di un array, ma non conta gli elementi presenti. Una scrittura per indice può estendere l’array; accorciarlo può eliminare elementi.

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

Sintassi

a.length
 a[i]
 a[i] = value
 a.length = newLength
 delete a[i]
 Object.hasOwn(a, i)
 a.at(-1)

a.length è una proprietà dati propria di un’istanza di Array, non un metodo né una proprietà statica. Gli indici partono da 0. Se la lunghezza è maggiore di zero, a.length - 1 indica l’ultima posizione, che può essere vuota. La lunghezza va da 0 a 2 ** 32 - 1; l’indice massimo di un array è 2 ** 32 - 2.

a[1] e a["1"] si riferiscono alla stessa chiave di proprietà. a["01"], a[-1] e a[2 ** 32 - 1] usano chiavi che non sono indici di array, quindi scrivervi non modifica la lunghezza. Invece a.at(-1) legge l’ultima posizione rispetto alla lunghezza e restituisce undefined se questa è zero.

Se una scrittura crea un elemento proprio all’indice i >= a.length, la lunghezza sale a i + 1 e le posizioni saltate restano vuote. Un buco non è un elemento proprio con valore undefined: una lettura con le parentesi quadre può trovare una proprietà ereditata e restituisce undefined se non trova alcuna proprietà corrispondente. Object.hasOwn(a, i) verifica la presenza di una proprietà propria; i in a considera anche la catena dei prototipi.

Aumentare length non crea elementi. Diminuirla elimina gli elementi propri con indice maggiore o uguale alla nuova lunghezza, partendo dall’indice più alto. Allungare di nuovo l’array non li ripristina. Un’operazione delete a[i] riuscita non accorcia l’array.

Assegnare a una length scrivibile un numero non intero o fuori dall’intervallo consentito genera RangeError. Un elemento non configurabile può bloccare l’accorciamento: la lunghezza si ferma al suo indice più uno e le eliminazioni già eseguite non vengono annullate. In modalità strict, questo errore di assegnazione genera TypeError; fuori da tale modalità, l’assegnazione può fallire senza segnalazioni.

Esempi

{
  const a = ["A", undefined];
  a[3] = "D";
  console.log(`${a.length} ${a[1]} ${a[2]}`);
  console.log(`${Object.hasOwn(a, 1)} ${Object.hasOwn(a, 2)}`);

  a[-1] = "label";
  console.log(`${a[-1]} ${a.at(-1)} ${a.length}`);

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

Risultato

4 undefined undefined
true false
label D 4
4 false label

Leggere gli indici `1` e `2` dà `undefined` in entrambi i casi, ma solo `1` è un elemento proprio. La chiave `-1` contiene `label`, mentre `a.at(-1)` dà `D`. L’accorciamento elimina `D`; allungare di nuovo l’array non lo ripristina e non modifica la proprietà `-1`.

Lezioni correlate

  • JavaScript · Lezione 28 · Avanzato · Versione: 4

Fonti