KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

CKTIS / JavaScript

Lengte en indexering van getypeerde arrays

`length` telt de elementen van een weergave, niet de bytes. Indexen beginnen bij nul en schrijven voorbij het laatste element vergroot de weergave niet.

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

Syntax

view.length
view[index]
view[index] = value
view.at(index)
new Uint16Array(buffer, byteOffset)
new Uint16Array(buffer, byteOffset, length)

Een getypeerde array, zoals Uint16Array, is een weergave van een buffer. view.length is een overgeërfde eigenschap met een getter maar zonder setter. Die telt elementen; view.byteLength telt de bytes in de weergave en view.buffer.byteLength de bytes in de hele buffer. Toewijzen aan view.length wijzigt de grootte van de weergave niet en veroorzaakt in strict mode een TypeError.

Elementindexen zijn gehele getallen van 0 tot en met view.length - 1. view[0] en view["0"] verwijzen naar hetzelfde element. Sleutels zoals "01" en "1.0" zijn gewone eigenschapsnamen, geen elementindexen. view[-0] gedraagt zich als view[0], maar view["-0"] geeft undefined terug.

Lezen op een ongeldige elementindex geeft undefined terug. Schrijven op die index wijzigt de buffer niet en voegt geen element toe, ook niet in strict mode, als de waarde kan worden geconverteerd. De conversie kan wel een fout veroorzaken, bijvoorbeeld bij het schrijven van een Number naar een BigInt64Array. Op een geldige index wordt de waarde volgens het elementtype opgeslagen. view[-1] telt niet vanaf het einde; view.at(-1) doet dat wel en geeft het laatste element van een niet-lege weergave terug.

Krijgt de constructor een ArrayBuffer waarvan de grootte kan worden aangepast of een SharedArrayBuffer die kan groeien, dan volgt de lengte van de weergave zonder derde argument length (of met undefined) het aantal volledige elementen vanaf byteOffset tot het huidige einde van de buffer. Bij een buffer met een vaste grootte maakt dezelfde aanroep een weergave met een vaste lengte. Het aantal bytes vanaf byteOffset tot het einde van de buffer moet dan een veelvoud zijn van de elementgrootte in bytes; anders veroorzaakt de constructor een RangeError. Een expliciete lengte legt het aantal elementen vast zolang de weergave in de buffer past. Valt de weergave na het verkleinen buiten de buffergrenzen, dan geeft length de waarde 0 terug; door de buffer weer te vergroten kan de weergave opnieuw passen. Ook het loskoppelen van de buffer leidt tot length === 0. In beide gevallen geeft lezen via een index undefined terug, maar veroorzaakt at() een TypeError.

Voorbeelden

"use strict";
{
  const view = new Uint16Array([10, 20]);
  view[1] = 65537;
  view[view.length] = 99;

  console.log(`${view.length} ${view.byteLength}`);
  console.log(`${view[0]} ${view[1]}`);
  console.log(`${view[view.length]} ${view[-1]} ${view.at(-1)}`);
}

Resultaat

2 4
10 1
undefined undefined 1

Twee `Uint16Array`-elementen nemen vier bytes in. Bij het opslaan van `65537` blijft `1` over, omdat alleen de laagste 16 bits behouden blijven. Schrijven op index `2` vergroot de weergave niet; `at(-1)` leest het laatste element.

Gerelateerde lessen

  • JavaScript · Les 33 · Gevorderd · Versie: 4
  • JavaScript · Les 34 · Gevorderd · Versie: 4

Bronnen