JavaScript typed arrays

Buffers and views: typed array architecture

Um maximal Flexibilität und Effizienz zu schaffen, spalten JavaScript Typed-Arrays  die Durchführung zwischen Buffers und Views. Ein Buffer (vom ArrayBuffer Objekt durchgeführt) ist ein Objekt, das eine Menge Daten verkörpert. Dazu gehört kein echtes Format, und keine Mechanismus wird angeboten, auf den Inhalt zuzugreifen. Um Zugang zu diesem Speicher zu schaffen, muss man ein "View" benutzen. Ein View liefert einen Kontext, der diese Daten ein echtes, typisiertes Array umwandelt. Genauer gesagt, gibt dieses Kontext ein Typ, Addressabstand und die Anzahl der Elemente an.

ArrayBuffer

Der ArrayBuffer ist ein Datentyp, der einen generischen, binärischen Datenpuffer mit festgelegte Länge darstellt. Es ist nicht möglich, der Inhalt dieses Puffers (ArrayBuffer) direkt zu bearbeiten, sondern bringt man einen DataView hervor. Dadurch wird den Puffer als ein spezifisches Format dargestellt, das benutzt wird, um den Inhalt des Puffers zu modifizieren und lesen.

Typed array views

"Typed Array Views" haben selbst beschreibende Namen, und bieten Views für alle die alltägliche Typen, wie Int8, Uint32, Float64 und so weiter. Es gibt auch einen spezialen Typed Array View: Uint8ClampedArray. Der begrenzt die Werte zwischen 0 und 255, was nützlich (als Beispiel) fur Canvas data processing ist.

DataView

Der DataView ist ein low-level Interface, das Getter und Setter zum Lesen und Schreiben beliebiger Daten in den Buffer anbietet. Das ist zum Beispiel nützlich, wenn man mit verschiedenen Datentypen arbeiten muss. "Typed Array Views" sind in der nativen Byte-Reihenfolge Ihrer Plattform (siehe Endianness. Mit einem DataView können Sie die Byte-Reihenfolge kontrollieren. Standardmässig ist Big-Endian eingestellt, Sie können es in den Gettern und Settern auf Little-Endian umstellen.

Web APIs mit Typed Arrays

FileReader.prototype.readAsArrayBuffer()

Die FileReader.prototype.readAsArrayBuffer() Methode liest den Inhalt aus einem gegebenen Blob oder einer Datei.

XMLHttpRequest.prototype.send()

Die send() Methode einer XMLHttpRequest-Instanz unterstützt nun Typed Arrays und ArrayBuffer Objekte als Argument.

ImageData.data

Ein Uint8ClampedArray welches die Daten in der RGBA-Reihenfolge enthält, mit Integer-Werten zwischen 0 und 255 inklusiv.

Beispiele

Views als Buffer benutzen

Als erstes muss ein Buffer erstellt werden, hier mit einer festgelegten Läneg von 16 Bytes:

var buffer = new ArrayBuffer(16);

Jetzt haben wir einen Block des Speichers mit Bytes, die mit 0 vor-initialisiert sind. Darüber hinaus lässt sich nicht viel damit anstellen. Wir können überprüfen, ob er wirklich 16 Bytes lange ist, und das war's auch schon.

if (buffer.byteLength === 16) {
  console.log("Yes, it's 16 bytes.");
} else {
  console.log("Oh no, it's the wrong size!");
} 

Bevor wir wirklich damit arbeiten können, müssen wir einen View erzeugen. Wir erstellen einen View, der die Daten in dem Buffer als ein Array von vorzeichenlosen 32-Bit Integern sieht.

var int32View = new Int32Array(buffer);

Jetzt können wir auf die Elemente in dem Array wie in jedem normalen Array zugreifen.

for (var i = 0; i < int32View.length; i++) {
  int32View[i] = i * 2;
}

Der obige Code füllt die 4 Einträge in dem Array (4 Einträge à 4 Bytes sind 16 Bytes insgesamt) mit den Werten 0, 2, 4 und 6.

Multiple views on the same data

Things start to get really interesting when you consider that you can create multiple views onto the same data. For example, given the code above, we can continue like this:

var int16View = new Int16Array(buffer);

for (var i = 0; i < int16View.length; i++) {
  console.log("Entry " + i + ": " + int16View[i]);
}

Here we create a 16-bit integer view that shares the same buffer as the existing 32-bit view and we output all the values in the buffer as 16-bit integers. Now we get the output 0, 0, 2, 0, 4, 0, 6, 0.

You can go a step farther, though. Consider this:

int16View[0] = 32;
console.log("Entry 0 in the 32-bit array is now " + int32View[0]);

The output from this is "Entry 0 in the 32-bit array is now 32". In other words, the two arrays are indeed simply views on the same data buffer, treating it as different formats. You can do this with any view types.

Working with complex data structures

By combining a single buffer with multiple views of different types, starting at different offsets into the buffer, you can interact with data objects containing multiple data types. This lets you, for example, interact with complex data structures from WebGL, data files, or C structures you need to use while using js-ctypes.

Consider this C structure:

struct someStruct {
  unsigned long id;
  char username[16];
  float amountDue;
};

You can access a buffer containing data in this format like this:

var buffer = new ArrayBuffer(24);

// ... read the data into the buffer ...

var idView = new Uint32Array(buffer, 0, 1);
var usernameView = new Uint8Array(buffer, 4, 16);
var amountDueView = new Float32Array(buffer, 20, 1);

Then you can access, for example, the amount due with amountDueView[0].

Conversion to normal arrays

After processing a typed array, it is sometimes useful to convert it back to a normal array in order to benefit from the Array prototype. This can done using Array.from, or using the following code where Array.from is unsupported.

var typedArray = new Uint8Array([1, 2, 3, 4]),
    normalArray = Array.prototype.slice.call(typedArray);
normalArray.length === 4;
normalArray.constructor === Array;

Spezifikationen

Browser compatibility

Chrome 7 includes support for ArrayBuffer, Float32Array, Int16Array, and Uint8Array. Chrome 9 and Firefox 15 add support for DataView objects. Internet Explorer 10 supports all types except Uint8ClampedArray and ArrayBuffer.prototype.slice which are present starting in Internet Explorer 11.

See also

• Getting ArrayBuffers or typed arrays from Base64-encoded strings
• StringView – a C-like representation of strings based on typed arrays
• Faster Canvas Pixel Manipulation with Typed Arrays
• Typed Arrays: Binary Data in the Browser
• Endianness