CKTIS / JavaScript
Arraylengte en indexering in JavaScript
`length` bepaalt de bovengrens voor indices, maar telt geen elementen. Schrijven naar een index kan die grens verleggen, en een lege plek is niet hetzelfde als `undefined`.
Versie: 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-indexen beginnen bij nul. a.length is een eigen eigenschap, standaard schrijfbaar maar niet configureerbaar. De waarde is een geheel getal van 0 tot en met 2 ** 32 - 1. Dit is de exclusieve bovengrens voor indexen van eigen elementen, niet het aantal elementen. Array.length geeft daarentegen het verwachte aantal parameters van de constructorfunctie aan, niet de lengte van een array.
Vierkante haken geven toegang tot eigenschappen: a[1] en a["1"] gebruiken dezelfde sleutel. Array-indexen zijn de canonieke decimale schrijfwijzen van gehele getallen van 0 tot en met 2 ** 32 - 2. Sleutels zoals "01", "-1" en "4294967295" zijn geen array-indexen en hebben geen invloed op de lengte. a[-1] zoekt de eigenschap "-1" op; a.at(-1) leest de laatste positie van een niet-lege array. Ligt de berekende index buiten het bereik, dan geeft at() undefined terug zonder die eigenschap op te zoeken.
Een eigen element aanmaken op i >= a.length vergroot de lengte tot i + 1. Overgeslagen posities blijven leeg. Een lege positie heeft geen eigen eigenschap; lezen levert undefined op tenzij er een waarde wordt geërfd. Object.hasOwn(a, i) onderscheidt zo’n lege positie van een eigen element met de waarde undefined. Een geslaagde delete a[i] verwijdert een element zonder de array in te korten.
Een grotere length voegt lege posities toe; een kleinere verwijdert eigen elementen vanaf de nieuwe grens. Als length schrijfbaar is, veroorzaakt het toewijzen van een Number-waarde die niet geheel is of buiten het toegestane bereik ligt een RangeError. Het toewijzen van een BigInt-waarde veroorzaakt daarentegen al tijdens de conversie een TypeError, nog voordat het bereik wordt gecontroleerd. Een niet-configureerbaar element kan het inkorten blokkeren: elementen met hogere indexen kunnen al verwijderd zijn, en de lengte blijft steken op de blokkerende index plus één. In strict mode veroorzaakt die mislukte toewijzing TypeError.
Voorbeelden
{
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]}`);
}Resultaat
length: 4 1: undefined, own: false 2: undefined, own: true [-1]: tag, at(-1): D length: 4, own 3: false, [-1]: tag
Zowel `1` als `2` levert bij het lezen `undefined` op, maar alleen `2` is een eigen element. Verlengen herstelt element `3` niet; de eigenschap `"-1"` blijft bestaan.
Gerelateerde lessen
- JavaScript · Les 41 · Gevorderd · Versie: 4