型付き配列 — Typed Array 仕様

2013 年 7 月 18 日付 草案

このバージョン
最新バージョン
https://www.khronos.org/registry/typedarray/specs/latest/
Web IDL: https://www.khronos.org/registry/typedarray/specs/latest/typedarray.idl
前のバージョン
https://www.khronos.org/registry/typedarray/specs/1.0/
Web IDL: https://www.khronos.org/registry/typedarray/specs/1.0/typedarray.idl
編集
David Herman (Mozilla Corporation)
Kenneth Russell (Google, Inc.)

要約

この仕様は、ネイティブ バイナリデータのやりとりを可能にする API を提供する。 これは、汎用の固定長バッファ型, および バッファ内に格納されたデータへのアクセスを許容する種々のアクセサ型を定義する。 This specification provides an API for interoperability with native binary data. It defines a generic fixed-length buffer type, as well as accessor types that allow access to the data stored within the buffer.

ここに述べられる機能は、元々は WebGL 仕様に端を発するものである。 [WEBGL] The functionality described here originated in the WebGL specification [WEBGL].

この文書の位置付け

この文書は草案です。 この文書を進行中の作業以上のものとして引用しないように。 WebGL メーリングリスト public_webgl@khronos.orgアーカイブ )にて、この仕様に関する公開の論が交わされています( 利用の手引き )。 This document is an editor's draft. Do not cite this document as other than work in progress. Public discussion of this specification is welcome on the (archived) WebGL mailing list public_webgl@khronos.org (see instructions).

この文書の,改訂履歴も含む最新バージョンは下記から入手できる: The latest version of this document, including all revision history, may be obtained via Subversion:

svn co https://cvs.khronos.org/svn/repos/registry/trunk/public/typedarray

1. 序

ECMAScript [ECMA-262] は、伝統的に,バイナリデータへのアクセスがない文脈の下で利用されてきた。 バイナリデータの操作を要する所では、しばしば, String として格納されたデータに charCodeAt() を利用してアクセスしたり, あるいは Array として格納されたデータとの間で base64 変換を介した受け渡しが行われている。 これらの手法は、いずれも低速であり,プログラムの誤りも導かれ易い。 例えば,バイナリデータを 32-bit 整数として読み取る際には、 4 個のソースバイトと目的の型との間の 手作業による変換コードを要する。 浮動小数点データの読み取りは更に高くつく。 ECMAScript [ECMA-262] has traditionally been used in contexts where there is no access to binary data. Where binary data has needed to be manipulated, it is often stored as a String and accessed using charCodeAt(), or stored as an Array with conversion to and from base64 for transmission. Both of these methods are slow and error-prone. For example, reading binary data as 32-bit integers requires manual conversion of 4 source bytes to and from the target type. Reading floating-point data is even more expensive.

ウェブアプリケーションが新たな機能性を獲得するに連れ、バイナリデータの取り扱いは,益々求められている機能になっている。 File API [FILEAPI] や WebSockets [WEBSOCKETS] などの現今の仕様は、ネイティブ形式によるバイナリデータの直接的な読み取りと書き込みが可能になれば、より便益を得られるようになる。 WebGL [WEBGL] などの仕様にとっては、この機能性が容認し得る性能に必須の要件になる。 As web applications gain access to new functionality, working with binary data has become a much-demanded feature. Current specifications such as the File API [FILEAPI] and Web Sockets [WEBSOCKETS] would benefit from being able to read and write binary data directly in its native form. Specifications such as WebGL [WEBGL] require this functionality to meet acceptable performance characteristics.

この仕様は、 ECMAScript からバイナリデータへアクセスするための,最小限の機能を定める。 This specification defines a minimal set of functionality for accessing binary data from ECMAScript.

【 この仕様に定義される各種インタフェースには、 ECMAScript 6 ( ECMAScript の次期バージョン)においては,対応する 組み込みの型が用意されている。 それに伴い, Web IDL でも 組み込みの型として扱われることになる。 】

2. 概観

この仕様は、汎用の固定長バイナリバッファを表現する ArrayBuffer 型を定義する。 ArrayBuffer の内容は、直接的には操作できない。 代わりに、 ArrayBuffer の各種 ビュー を作成する,一連の型が利用される。 例えば、バッファに対し, 32-bit 符号付き整数の配列としてアクセスするときは、 ArrayBuffer を参照する Int32Array を作成することになる。 This specification defines an ArrayBuffer type, representing a generic fixed-length binary buffer. It is not possible to manipulate the contents of an ArrayBuffer directly. Instead, a group of types are used to create views of the ArrayBuffer. For example, to access the buffer as an array of 32-bit signed integers, an Int32Array would be created that refers to the ArrayBuffer.

複数の型付き配列ビューを通して、同じ ArrayBuffer に対し,種々の型, 任意の 長さ/オフセットによる参照が可能になる。 また、複雑なデータ構造を持つ ArrayBuffer も構築可能になる。 例えば,次のコードでは: Multiple typed array views can refer to the same ArrayBuffer, of different types, lengths, and offsets. This allows for complex data structures to be built up in the ArrayBuffer. As an example, given the following code:

      // 8 バイトの ArrayBuffer を作成
      var b = new ArrayBuffer(8);

      // b の始端(既定の, バイトindex 0 )の所から
      // バッファ終端までを参照する Int32 型のビュー, v1 を作成
      var v1 = new Int32Array(b);

      // b のバイトindex 2 の所から
      // バッファ終端までを参照する Uint8 型のビュー, v2 を作成
      var v2 = new Uint8Array(b, 2);

      // b のバイトindex 2 の所から
      // 長さ 2 の範囲を参照する Int16 型のビュー, v3 を作成
      var v3 = new Int16Array(b, 2, 2);

次のようなバッファ, およびビューの割り付けが作成される: The following buffer and view layout is created:

変数index
バイト列( index アクセス不可)
b = 01234567
アクセス index
v1 = 01
v2 = 012345
v3 = 01

これは、 8 バイトのバッファ b と, 3個のバッファビュー v1, v2, v3 を定義する。 これらのビューは、同じバッファを参照する。 すなわち: v1[0] は,バイト 0 〜 3 を符号付き 32-bit 整数として参照し,
v2[0] は,バイト 2 を符号なし 8-bit 整数として参照し,
v3[0] は,バイト 2 〜 3 を符号付き 16-bit 整数として参照する。
1つのビューに加えられた変更は、即時に他から見えるようになる: 例えば, v2[0] = 0xff; v2[1] = 0xff; が実行されたなら、
v3[0] == -1 となる(そこでは, −1 は 0xffff で表現される)。
This defines an 8-byte buffer b, and three views of that buffer, v1, v2, and v3. Each of the views refers to the same buffer -- so v1[0] refers to bytes 0..3 as a signed 32-bit integer, v2[0] refers to byte 2 as a unsigned 8-bit integer, and v3[0] refers to bytes 2..3 as a signed 16-bit integer. Any modification to one view is immediately visible in the other: for example, after v2[0] = 0xff; v2[1] = 0xff; then v3[0] == -1 (where -1 is represented as 0xffff).

2.1. endianness

コンピュータのメモリは,基本的に 数値の連続的な並びで編成されている。 現今のすべてのコンピュータでは、これらのそれぞれの値が 8-bit バイナリ数( “バイト” )である。 より大きな数は、複数個のバイト( “複バイト” )をまとめて1個の値に解釈することで表現される。 例えば この仕様は、 16-bit, 32-bit の符号付き/符号なしの整数, および 32-bit, 64-bit 浮動小数点数について論じる。 Computer memory is fundamentally organized as a linear series of numbers. On all contemporary computers, each of these values is an 8-bit binary number (a "byte"). Larger numbers are represented by interpreting multiple bytes at a time as a single value. For example, this specification discusses 16-bit and 32-bit signed and unsigned integers, and 32-bit and 64-bit floating-point numbers.

そのような複バイト値の解釈には,バイトの並び順の解釈に多義性を孕む。 little-endian アーキテクチャの下では,最低アドレスのバイトが最下位バイトとして扱われ、 big-endian アーキテクチャの下では,最低アドレスのバイトが最上位バイトとして扱われる。 他の可能性もあるが、普通は利用されない。 現代の大多数の消費者コンピュータ機器では, little-endian アーキテクチャが利用されているが、 big-endian アーキテクチャも依然として重要なユースケースの下で利用されている。 There exists an ambiguity in the interpretation of such multi-byte values: specifically, which order the bytes are assembled. Little-endian architectures treat the byte with the lowest address as the least significant byte; big-endian architectures treat the byte with the lowest address as the most significant byte. More possibilities exist, but are not commonly used. Little-endian architectures are currently used in most consumer computing devices, but big-endian architectures are still used in important use cases.

次の図式に,little-endian と big-endian の下での値の格納の相違を示す。 値 305419896 ( 16進 0x12345678 )が Uint32Array を用いて ArrayBuffer の中に格納されているとするとき、ホストコンピュータの endianness に依存して、 ArrayBuffer の各バイト成分は(アドレスの低い方から順に)次の様に並ぶことになる: The following diagram illustrates the difference in storage of values between little-endian and big-endian architectures. If the value 305419896 (0x12345678 in hexadecimal) were stored into an ArrayBuffer using a Uint32Array, then depending on the host computer's endianness, the component bytes of the ArrayBuffer would contain the following (organized from low address to high address):

little-endian:78563412
big-endian:12345678

この仕様では、 endianness による相違は,一定の状況に限り露になる: 例えば, ArrayBuffer の同じ区域に複数種のビューの型が重なるときなど。 次の規範規則が,型付き配列ビューの実装に適用される: In this specification, differences in endianness only become apparent in certain situations: for example, when overlaying multiple types of views on the same region of an ArrayBuffer. The following normative rules apply to implementations of the typed array views.

型付き配列ビュー型 は、ホストコンピュータの endianness の下で,演算を行う。 The typed array view types operate with the endianness of the host computer.

DataView ビュー型 は、指定された endianness ( big-endian または little-endian )の下で,演算を行う。 The DataView type operates upon data with a specified endianness (big-endian or little-endian).

型付き配列ビュー型( Uint8Array, Float32Array, 等々)は、グラフィックスカード, オーディオシステム, 等へ向けて送信されるような,巨大なデータブロックのメモリ内構成のために設計されている。 この種の用途では、データをメインメモリに書き込む際にホストマシンのネイティブ endianness の利用が要求される。 この仕様が型付き配列ビュー型に対し,一貫する指定された endianness (例えば little-endian )の利用を義務付けない理由は、一部の CPU アーキテクチャ(この場合, big-endian アーキテクチャ)で稼働するグラフィックスカードからデータが誤って解釈されたり,その種のアーキテクチャに容認できない高い処理オーバーヘッドを課さないようにするためである。 The typed array view types (Uint8Array, Float32Array, etc.) are designed for in-memory assembly of large blocks of data to be sent to the graphics card, audio system, etc. For these use cases, it is required to use the native endianness of the host machine when writing the data to main memory. If this specification had mandated for consistency that the typed array view types used a specified endianness (for example, little-endian), the data would either be misinterpreted by the graphics card on some processor architectures (in this example, big-endian architectures), or impose an unacceptably high performance overhead on such architectures.

データが,他のコンピュータから受信されたり, ディスク上のファイルから読み取られる際に,ホストコンピュータの endianness に関わらず 正しく解釈されるためには、データのバイト順の指定が決定的に重要になる。 基本的に,既存のどのファイル形式/ネットワークプロトコルでも、そのデータ形式は,ファイルやネットワークのペイロードに含まれるすべての複バイトデータのバイト順を含め,明確に指定されている。 DataView ビュー型は,入出力タスクのために設計されており、したがって,指定されたバイト順のデータに対し演算を行う。 ホストコンピュータの endianness は DataView の処理には影響しない。 そのデータの読み書きは常に、データが特定の endianness で格納されていることを前提に,行われる。 When receiving data from other computers, or reading files from disk, it is critical to specify the byte order of the data so that it can be properly interpreted regardless of the endianness of the host computer. Essentially every file format or network protocol in existence has a clearly specified data format, including the byte order of all multi-byte data contained in the file or network payload. The DataView view type is designed for input/output tasks and therefore operates upon data with a specified byte order. The host computer's endianness is irrelevant when working with DataView; it always reads or writes data assuming that data is stored with a particular endianness.

より深い背景と考察が 型付き配列ビューの設計と利用についての論説 和訳 に見られる。 This article on the design and usage of the typed array views may provide more background and in-depth discussion.

3. 型変換の規則

仕様の以下の部分では、例えば,浮動小数点値から種々のサイズの整数値への変換などにおいて、一定の型変換の規則が暗黙的に参照される。 これらの規則は Web IDL 仕様 [WEBIDL] が定義し, ToInt32 などの変換のアルゴリズムについては ECMA-262仕様 [ECMA-262] が参照される。 The specification below implicitly references certain type conversion rules; for example, conversion of floating-point values to integer values of various sizes. The Web IDL specification [WEBIDL] defines these rules, and references the ECMA-262 specification [ECMA-262] for conversion algorithms such as ToInt32.

この仕様が参照している Web IDL 仕様は、現時点ではすべての数値型を定義していない。 例えば, byte は符号付き 8-bit 整数型である。 【 現在の Web IDL 仕様では実質的にすべて定義されている。】 これらの型については、最も近い[ サイズ, 正負符号の有無 ]の型に適用される規則から,推定されるものとする。 The Web IDL specification does not currently define all of the numerical types referenced in this specification; for example, byte, which is a signed 8-bit integer type. For these types, the rules for the type of the closest size and signedness shall be extrapolated.

ECMA-262 仕様のアルゴリズムの実装者へのヒント: 浮動小数点数から整数値への変換では、 truncate あるいは round-to-zero が丸めモードに利用される As a hint to implementors of the algorithms in the ECMA-262 specification, conversion of floating-point numbers to integer values uses the truncate, or round-to-zero, rounding mode.

4. NaN ( Not-a-Number )値の扱い

非数値( NaN )値が Float32ArrayFloat64Array に格納されるとき, あるいは setFloat32setFloat64 メソッドを利用して DataView に格納されるときの,下層の ArrayBuffer に書き込まれる bit パタンは指定されないが、 IEEE 754 による NaN を表現するいずれかの bit パタンになるものとする。 [IEEE-754] When the not-a-number (NaN) value is stored into a Float32Array or Float64Array, or into a DataView using the setFloat32 or setFloat64 methods, the bit pattern written into the underlying ArrayBuffer is not specified, but shall be one of the IEEE 754 bit patterns that represent NaN [IEEE-754].

IEEE 754 による NaN を表現する bit パタンが Float32ArrayFloat64Array から読み込まれる, あるいは getFloat32getFloat64 メソッドを利用して DataView から読み込まれるときには、言語束縛(例えば, ECMAScript )は,その NaN 値を表現する代替の bit パタンを利用してもよい。 When a bit pattern representing an IEEE 754 NaN is loaded from a Float32Array or Float64Array, or from a DataView using the getFloat32 or getFloat64 methods, the language binding (for example, ECMAScript) may use an alternative bit pattern to represent the NaN value.

Web IDL [WEBIDL] および ECMA-262 [ECMA-262] 仕様が NaN 値についての他のすべての取り扱いを定める。 特に, NaN が整数値に変換される際は、常に 0 に変換される。 The Web IDL [WEBIDL] and ECMA-262 [ECMA-262] specifications govern all other handling of NaN values, in particular the conversion to 0 when converting NaN to an integer value.

5. ArrayBuffer

ArrayBuffer 型は、配列バッファビューを通してデータを格納する際に利用されるバッファを表現する。 ArrayBuffer は次のメソッドとプロパティを持つ: The ArrayBuffer type describes a buffer used to store data for the array buffer views. An ArrayBuffer has the following methods and properties:

[ Constructor(unsigned long length) ]
interface ArrayBuffer {
    readonly attribute unsigned long byteLength;
    ArrayBuffer    slice(long begin, optional long end);
    static boolean isView(any value);
};
ArrayBuffer implements Transferable;
構築子
ArrayBuffer(unsigned long length)

与えられたバイト長の新たな ArrayBuffer 作成する。 ArrayBuffer の内容は 0 に初期化される。 要求されたバイト数を割り当てられなかった場合、例外が投出される。 Creates a new ArrayBuffer of the given length in bytes. The contents of the ArrayBuffer are initialized to 0. If the requested number of bytes could not be allocated an exception is raised.

プロパティ
unsigned long byteLength

読み取り専用。 Read-only property.

ArrayBuffer のバイト数による長さ。 構築時に一定値に固定される。 The length of the ArrayBuffer in bytes, as fixed at construction time.

この ArrayBuffer が無力化されている場合†、このプロパティは,読み取り時に 0 を返す。 【† transferable objects Reading this property returns 0 if this ArrayBuffer has been neutered.

メソッド
ArrayBuffer slice(long begin, optional long end)

この ArrayBufferbegin から end の直前までのバイトの複製を内容とする,新たな ArrayBuffer を返す。 負の beginend は、始端からとは逆に,配列の終端からの index を指す。 Returns a new ArrayBuffer whose contents are a copy of this ArrayBuffer's bytes from begin, inclusive, up to end, exclusive. If either begin or end is negative, it refers to an index from the end of the array, as opposed to from the beginning.

end が指定されなかった場合、新たな ArrayBuffer は, begin からこの ArrayBuffer の終端までのすべてのバイトを含むことになる。 If end is unspecified, the new ArrayBuffer contains all bytes from begin to the end of this ArrayBuffer.

begin 値と end 値で指定される範囲は、現在の配列の有効な index 範囲に切り詰められる。 新たな ArrayBuffer に対し算出される長さが負になる場合、ゼロに切り上げられる。 The range specified by the begin and end values is clamped to the valid index range for the current array. If the computed length of the new ArrayBuffer would be negative, it is clamped to zero.

static boolean isView(any value)

valueArrayBufferView インタフェースを実装するオブジェクトであれば true を, 他の場合は false を返す。 Returns true if value is an object implementing the ArrayBufferView interface, and false otherwise.

6. ArrayBufferView

ArrayBufferView 型は、 ArrayBuffer のビュー型すべてに共通の情報を保持する。 ArrayBufferView は、次のプロパティを持つ: The ArrayBufferView type holds information shared among all of the types of views of ArrayBuffers. An ArrayBufferView has the following properties:

[NoInterfaceObject]
interface ArrayBufferView {
    readonly attribute ArrayBuffer   buffer;
    readonly attribute unsigned long byteOffset;
    readonly attribute unsigned long byteLength;
};
構築子
なし
プロパティ
ArrayBuffer buffer

読み取り専用。 Read-only property.

この ArrayBufferView が参照している ArrayBuffer The ArrayBuffer that this ArrayBufferView references.

unsigned long byteOffset

読み取り専用。 Read-only property.

この ArrayBufferView が参照している ArrayBuffer の始端からの,バイト数によるオフセット。 構築時に一定値に固定される。 The offset of this ArrayBufferView from the start of its ArrayBuffer, in bytes, as fixed at construction time.

参照されている ArrayBuffer が無力化されている場合、このプロパティは,読み取り時に 0 を返す。 Reading this property returns 0 if the referenced ArrayBuffer has been neutered.

unsigned long byteLength

読み取り専用。 Read-only property.

ArrayBufferView のバイト数による長さ。 構築時に一定値に固定される。 The length of the ArrayBufferView in bytes, as fixed at construction time.

参照されている ArrayBuffer が無力化されている場合、このプロパティは,読み取り時に 0 を返す。 Reading this property returns 0 if the referenced ArrayBuffer has been neutered.

メソッド
なし

7. 型付き配列ビュー型

型付き配列ビュー( typed array view )型は、 ArrayBuffer のデータへの index アクセスと操作を可能にするビューを表現する。 これらそれぞれの長さは、構築時に一定値に固定される。 それぞれの型付き配列ビュー型は、同じひな型に従う。 The typed array view types represent a view of an ArrayBuffer that allows for indexing and manipulation. The length of each of these is fixed. Each of the typed array view types follows the same template.

次の型付き配列ビュー型がこの仕様にて定義される。 下の一覧におけるサイズは,バイト数で与えられ、与えられた型の BYTES_PER_ELEMENT 定数に対応する。 The following typed array view types are defined by this specification. The size below is given in bytes, and corresponds to the BYTES_PER_ELEMENT constant for the given type.

サイズ 説明 Web IDL 型 等価な C の型
Int8Array1 2 の補数による,
8-bit 符号付き整数 8-bit 2's complement signed integer
byte signed char
Uint8Array1 8-bit 符号なし整数
8-bit unsigned integer
octet unsigned char
Uint8ClampedArray1 8-bit 符号なし整数
(切り詰めあり) 8-bit unsigned integer (clamped)
octet unsigned char
Int16Array2 2 の補数による,
16-bit 符号付き整数 16-bit 2's complement signed integer
short short
Uint16Array2 16-bit 符号なし整数
16-bit unsigned integer
unsigned short unsigned short
Int32Array4 2 の補数による,
32-bit 符号付き整数 32-bit 2's complement signed integer
long int
Uint32Array4 32-bit 符号なし整数
32-bit unsigned integer
unsigned long unsigned int
Float32Array4 32-bit
IEEE 浮動小数点数 32-bit IEEE floating point
unrestricted float float
Float64Array8 64-bit
IEEE 浮動小数点数 64-bit IEEE floating point
unrestricted double double

それぞれの型付き配列型は、次の構築子, プロパティ, 定数, メソッドを持つ。 以下の記述では、許容される種々の 型付き配列ビュー型 を指す総称として,語 TypedArray が利用される。 【また、 type はその TypedArray の要素の Web IDL 型を表すものとする。】 ただし, Uint8ClampedArray については、次節にて定義される。 Each of the typed array types has the following constructors, properties, constants and methods. In the descriptions below, the generic term TypedArray is used to indicate that any valid typed array view type is allowed. Uint8ClampedArray is defined in the next section.

いずれかの TypedArray インタフェースを実装する array オブジェクトは、 範囲 0 ≤ index < array.lengthindex 付きプロパティをサポートする[WEBIDL] An object array implementing one of the TypedArray interfaces supports indexed properties [WEBIDL] with indices in the range 0 ≤ index < array.length.

複バイト値に対する演算を行う型付き配列ビューは、メインメモリからの値の読み書きをホストコンピュータの endianness の下で行う。 Typed array views operating upon multi-byte values use the host computer's endianness when reading or writing values from or to main memory.

[
    Constructor(unsigned long length),
    Constructor(TypedArray array),
    Constructor(type[] array),
    Constructor(ArrayBuffer buffer,
                optional unsigned long byteOffset,
                optional unsigned long length)
]
interface TypedArray {
    const unsigned long BYTES_PER_ELEMENT = <バイト数による要素サイズ>;

    readonly attribute unsigned long length;

    getter type get(unsigned long index);
    setter void set(unsigned long index, type value);
    void        set(TypedArray array, optional unsigned long offset);
    void        set(type[] array, optional unsigned long offset);
    TypedArray  subarray(long begin, optional long end);
};
TypedArray implements ArrayBufferView;
構築子
TypedArray(unsigned long length)

この型付き配列の length 個の要素を保持するに十分なバイト数の,新たな ArrayBuffer を作成した上で、そのバッファ全体を参照する型付き配列ビューを作成する。 直接的に構築される ArrayBuffer と同様、内容は 0 に初期化される。 要求されたバイト数を割り当てられなかった場合、例外が投出される。 Create a new ArrayBuffer with enough bytes to hold length elements of this typed array, then creates a typed array view referring to the full buffer. As with a directly constructed ArrayBuffer, the contents are initialized to 0. If the requested number of bytes could not be allocated an exception is raised.

TypedArray(TypedArray array)
TypedArray(type[] array)

この型付き配列の array.length 個の要素を保持するに十分なバイト数の,新たな ArrayBuffer を作成した上で、そのバッファ全体を参照する型付き配列ビューを作成する。 新たなビューの内容のそれぞれの要素は、与えられた配列または型付き配列の内容から,型付き配列の型に適切に変換された上で、初期化される。 Create a new ArrayBuffer with enough bytes to hold array.length elements of this typed array, then creates a typed array view referring to the full buffer. The contents of the new view are initialized to the contents of the given array or typed array, with each element converted to the appropriate typed array type.

TypedArray(ArrayBuffer buffer, optional unsigned long byteOffset, optional unsigned long length)

buffer 引数に渡された ArrayBuffer をデータ格納域に利用する,新たな TypedArray オブジェクトを作成する。 byteOffset (省略可)と length が、参照されるバッファの区間の制限に利用される。 byteOffset は、 buffer の始端からの,バイト数によるオフセットを指示する。 length は、オフセットからの,この TypedArray が参照する要素の個数になる。 byteOffsetbyteLength が両方とも省略された場合、 TypedArray が参照する区間は, ArrayBuffer 全域に渡る。 byteLength が省略された場合、参照する区間は,与えられた byteOffset から ArrayBuffer の終端までに渡る。 Create a new TypedArray object using the passed ArrayBuffer for its storage. Optional byteOffset and length can be used to limit the section of the buffer referenced. The byteOffset indicates the offset in bytes from the start of the ArrayBuffer, and the length is the count of elements from the offset that this TypedArray will reference. If both byteOffset and length are omitted, the TypedArray spans the entire ArrayBuffer range. If the length is omitted, the TypedArray extends from the given byteOffset until the end of the ArrayBuffer.

byteOffset は、型に固有の要素サイズの倍数でなければならない。 そうでない場合、例外が投出される。 The given byteOffset must be a multiple of the element size of the specific type, otherwise an exception is raised.

byteOffsetlength により参照される範囲が ArrayBuffer の終端を超えている場合、例外が投出される。 If a given byteOffset and length references an area beyond the end of the ArrayBuffer an exception is raised.

length が省略された場合、 ( ArrayBuffer の長さ − byteOffset ) は,型に固有の要素サイズの整数倍でなければならない。 そうでない場合、例外が投出される。 If length is not explicitly specified, the length of the ArrayBuffer minus the byteOffset must be a multiple of the element size of the specific type, or an exception is raised.

定数
unsigned long BYTES_PER_ELEMENT

バイト数による,配列の各要素のサイズ。 The size in bytes of each element in the array.

プロパティ
unsigned long length

読み取り専用。 Read-only property.

要素数による, TypedArray の長さ。 構築時に一定値に固定される。 The length of the TypedArray in elements, as fixed at construction time.

参照されている ArrayBuffer が無力化されている場合、このプロパティは,読み取り時に 0 を返す。 Reading this property returns 0 if the referenced ArrayBuffer has been neutered.

メソッド
getter type get(unsigned long index)

これは index 付き取得子 ( indexed getter )である。 This is an index getter.

与えられた数値 index に位置する要素を返す。 Returns the element at the given numeric index.

Float32ArrayFloat64Array に適用される追加の規則については、 NaN 値の扱い を見よ。 See handling of NaN values for additional rules covering Float32Array and Float64Array.

setter void set(unsigned long index, type value)

これは index 付き設定子 ( indexed setter )である。 This is an index setter.

与えられた数値 index に位置する要素を与えられた value にする。 Sets the element at the given numeric index to the given value.

値から type への変換は、 型変換規則NaN 値の扱い により定義される。 Conversions of values to type are defined by the type conversion rules and handling of NaN values.

void set(TypedArray array, optional unsigned long offset)
void set(type[] array, optional unsigned long offset)

array から読み取られる入力値により、複数個の要素の値を設定する。 Set multiple values, reading input values from the array.

offset (省略可)は、現在の配列に値を書き込む最初の index を指示する。 省略された場合、 0 と見なされる。 The optional offset value indicates the index in the current array where values are written. If omitted, it is assumed to be 0.

入力配列が TypedArray である場合、二つの配列が,同じ下層の ArrayBuffer を利用していることもあり得る。 この状況における値の設定は、すべてのデータが,いずれの配列にも重ならない一時バッファにいったん複製されてから,その一時バッファのデータが現在の配列に複製されるかのように、ふるまうものとする。 If the input array is a TypedArray, the two arrays may use the same underlying ArrayBuffer. In this situation, setting the values takes place as if all the data is first copied into a temporary buffer that does not overlap either of the arrays, and then the data from the temporary buffer is copied into the current array.

offset + 与えられた配列の長さ ]が現在の TypedArray の範囲を超えている場合、例外が投出される。 If the offset plus the length of the given array is out of range for the current TypedArray, an exception is raised.

TypedArray subarray(long begin, optional long end)

この TypedArray が参照する ArrayBuffer と同じ ArrayBuffer を参照し,この TypedArraybegin から end の直前までの要素を参照する、新たな TypedArray ビューを返す。 負の beginend は、始端からとは逆に,配列の終端からの index を表す。 Returns a new TypedArray view of the ArrayBuffer store for this TypedArray, referencing the elements at begin, inclusive, up to end, exclusive. If either begin or end is negative, it refers to an index from the end of the array, as opposed to from the beginning.

end が指定されなかった場合、 subarray には, begin から TypedArray の終端までのすべての要素が含まれる。 If end is unspecified, the subarray contains all elements from begin to the end of the TypedArray.

begin 値と end 値で指定される範囲は、現在の配列の有効な index 範囲に切り詰められる。 新たな ArrayBuffer に対し算出される長さが 負になる場合、ゼロに切り上げられる。 The range specified by the begin and end values is clamped to the valid index range for the current array. If the computed length of the new TypedArray would be negative, it is clamped to zero.

返される TypedArray の型は,このメソッドが呼び出された配列と同じになる。 The returned TypedArray will be of the same type as the array on which this method is invoked.

7.1. Uint8ClampedArray

Uint8ClampedArray は、 CanvasPixelArray を置き換えるためのものである。 そのふるまいは、設定子と構築子において 入力数値を変換する際に、 modulo 算術ではなく, 切り詰め [WEBIDL] が利用されることを除き、他の型付き配列ビューと同じになる。 Uint8ClampedArray の IDL は次で与えられる: Uint8ClampedArray is defined in order to replace CanvasPixelArray. It behaves identically to the other typed array views, except that the setters and constructor use clamping [WEBIDL] rather than modulo arithmetic when converting incoming number values. The IDL for Uint8ClampedArray follows.

// 現時点では、 'unsigned byte' 型は Web IDL に存在しないが、
// 'octet' がそれに等価なものにあたる。
[
    Constructor(unsigned long length),
    Constructor(Uint8ClampedArray array),
    Constructor(octet[] array),
    Constructor(ArrayBuffer buffer,
                optional unsigned long byteOffset,
                optional unsigned long length)
]
interface Uint8ClampedArray {
    const unsigned long BYTES_PER_ELEMENT = 1;

    readonly attribute unsigned long length;

    getter octet get(unsigned long index);
    setter void  set(unsigned long index, [Clamp] octet value);
    void         set(Uint8ClampedArray array, optional unsigned long offset);
    void         set(octet[] array, optional unsigned long offset);
    Uint8ClampedArray subarray(long begin, optional long end);
};
Uint8ClampedArray implements ArrayBufferView;

8. DataView ビュー型

ArrayBuffer は、任意のデータ域の表現に有用になるオブジェクトである。 多くの場合、その種のデータは,ディスクやネットワークから読み取られ、これまでに述べた,型付き配列ビューに課されているアラインメントの制約には従わない。 加えて、データはしばしば,その特質から雑多な要素から構成され, 定義済みのバイト順を持つ。 DataView ビューは、その種のデータの ArrayBuffer からの読み取り/への書き込みを可能にする,低レベルのインタフェースを提供する。 An ArrayBuffer is a useful object for representing an arbitrary chunk of data. In many cases, such data will be read from disk or from the network, and will not follow the alignment restrictions that are imposed on the typed array views described earlier. In addition, the data will often be heterogeneous in nature and have a defined byte order. The DataView view provides a low-level interface for reading such data from and writing it to an ArrayBuffer.

コンピュータの endianness に関わらず、 DataView は メインメモリに対する値の読み書きを,指定された endianness ( big または little )の下で行う。 Regardless of the host computer's endianness, DataView reads or writes values to or from main memory with a specified endianness: big or little.

[
  Constructor(ArrayBuffer buffer,
              optional unsigned long byteOffset,
              optional unsigned long byteLength)
]
interface DataView {
    // ビューの始端から 指定されたバイトオフセットの所から,
    // 与えられた型による値を取得する。アラインメントの拘束はなく、
    // 任意のオフセットの所から複バイト値を取得できる。
    //
    // 複バイト値に対しては、 littleEndian 引数(省略可)が,
    // 格納されているデータを big-endian 値か little-endian 値の
    // いずれとして読み取るべきかを指示する。false または undefined
    // の場合、big-endian 値として読み取られる。
    //
    // これらのメソッドで、ビューの終端を超える読み取りが
    // 試みられた場合,例外が投出される。

    byte           getInt8(unsigned long byteOffset);
    octet          getUint8(unsigned long byteOffset);
    short          getInt16(unsigned long byteOffset,
                            optional boolean littleEndian);
    unsigned short getUint16(unsigned long byteOffset,
                             optional boolean littleEndian);
    long           getInt32(unsigned long byteOffset,
                            optional boolean littleEndian);
    unsigned long  getUint32(unsigned long byteOffset,
                             optional boolean littleEndian);
    float          getFloat32(unsigned long byteOffset,
                              optional boolean littleEndian);
    double         getFloat64(unsigned long byteOffset,
                              optional boolean littleEndian);

    // ビューの始端から 指定されたバイトオフセットの所から,
    // 与えられた型による値を格納する。アラインメントの拘束はなく、
    // 任意のオフセットの所から複バイト値を格納できる。
    //
    // 複バイト値に対しては、 littleEndian 引数(省略可)が,
    // データを big-endian か little-endian のいずれのバイト順で格納すべき
    // であるかを指示する。 false または undefined の場合、 
    // big-endian によるバイト順で格納される。
    //
    // これらのメソッドで、ビューの終端を超える書き込みが
    // 試みられた際には,例外が投出される。

    void setInt8(unsigned long byteOffset,
                 byte value);
    void setUint8(unsigned long byteOffset,
                  octet value);
    void setInt16(unsigned long byteOffset,
                  short value,
                  optional boolean littleEndian);
    void setUint16(unsigned long byteOffset,
                   unsigned short value,
                   optional boolean littleEndian);
    void setInt32(unsigned long byteOffset,
                  long value,
                  optional boolean littleEndian);
    void setUint32(unsigned long byteOffset,
                   unsigned long value,
                   optional boolean littleEndian);
    void setFloat32(unsigned long byteOffset,
                    float value,
                    optional boolean littleEndian);
    void setFloat64(unsigned long byteOffset,
                    double value,
                    optional boolean littleEndian);
};
DataView implements ArrayBufferView;

DataView では、次の構築子, プロパティ, メソッドが利用できる: The following constructors, properties, and methods are available on a DataView:

構築子
DataView(ArrayBuffer buffer, optional unsigned long byteOffset, optional unsigned long byteLength)

引数に渡された ArrayBuffer をデータ格納域に利用する,新たな DataView オブジェクトを作成する。 byteOffset (省略可)と byteLength が、参照するバッファの区間の制限に利用される。 byteOffsetは、 ArrayBuffer の始端からの,バイト数によるオフセットを指示する。 byteLength は、オフセットからの,この DataView が参照するバイト数を与える。 byteOffsetbyteLength が両方とも省略された場合、 DataView が参照する区間は, ArrayBuffer 全域に渡る。 byteLength が省略された場合、参照する区間は,与えられた byteOffset から ArrayBuffer の終端までに渡る。 Create a new DataView object using the passed ArrayBuffer for its storage. Optional byteOffset and byteLength can be used to limit the section of the buffer referenced. The byteOffset indicates the offset in bytes from the start of the ArrayBuffer, and the byteLength is the number of bytes from the offset that this DataView will reference. If both byteOffset and byteLength are omitted, the DataView spans the entire ArrayBuffer range. If the byteLength is omitted, the DataView extends from the given byteOffset until the end of the ArrayBuffer.

byteOffsetbyteLength により参照される範囲が ArrayBuffer の終端を超えている場合、例外が投出される。 If the given byteOffset and byteLength references an area beyond the end of the ArrayBuffer an exception is raised.

プロパティ
なし
メソッド
byte getInt8(unsigned long byteOffset);
octet getUint8(unsigned long byteOffset);
short getInt16(unsigned long byteOffset, optional boolean littleEndian);
unsigned short getUint16(unsigned long byteOffset, optional boolean littleEndian);
long getInt32(unsigned long byteOffset, optional boolean littleEndian);
unsigned long getUint32(unsigned long byteOffset, optional boolean littleEndian);
float getFloat32(unsigned long byteOffset, optional boolean littleEndian);
double getFloat64(unsigned long byteOffset, optional boolean littleEndian);

ビューの始端からのバイトオフセット byteOffset の所から,与えられた型による値を取得する。 アラインメントの拘束はなく、任意のオフセットの所から複バイト値を取得できる。 Gets the value of the given type at the specified byte offset from the start of the view. There is no alignment constraint; multi-byte values may be fetched from any offset.

複バイト値に対しては、 littleEndian 引数(省略可)が,格納されているデータを big-endian 値か little-endian 値のいずれとして読み取るべきかを指示する。 false または undefined の場合、 big-endian 値として読み取られる。 For multi-byte values, the optional littleEndian argument indicates whether a big-endian or little-endian value should be read. If false or undefined, a big-endian value is read.

これらのメソッドで、ビューの終端を超える読み取りが試みられた場合,例外が投出される。 These methods raise an exception if they would read beyond the end of the view.

getFloat32getFloat64 に適用される追加の規則については、 NaN 値の扱い を見よ。 See handling of NaN values for additional rules covering getFloat32 and getFloat64.

void setInt8(unsigned long byteOffset, byte value);
void setUint8(unsigned long byteOffset, octet value);
void setInt16(unsigned long byteOffset, short value, optional boolean littleEndian);
void setUint16(unsigned long byteOffset, unsigned short value, optional boolean littleEndian);
void setInt32(unsigned long byteOffset, long value, optional boolean littleEndian);
void setUint32(unsigned long byteOffset, unsigned long value, optional boolean littleEndian);
void setFloat32(unsigned long byteOffset, float value, optional boolean littleEndian);
void setFloat64(unsigned long byteOffset, double value, optional boolean littleEndian);

ビューの始端からのバイトオフセット byteOffset の所から,与えられた型による値を格納する。 アラインメントの拘束はなく、任意のオフセットの所から複バイト値を格納できる。 Stores a value of the given type at the specified byte offset from the start of the view. There is no alignment constraint; multi-byte values may be stored at any offset.

複バイト値に対しては、 littleEndian 引数(省略可)が,データを big-endian か little-endian のいずれのバイト順で格納すべきであるかを指示する。 false または undefined の場合、 big-endian によるバイト順で格納される。 For multi-byte values, the optional littleEndian argument indicates whether the value should be stored in big-endian or little-endian byte order. If false or undefined, the value is stored in big-endian byte order.

これらのメソッドでは、ビューの終端を超える書き込みが試みられた際には,例外が投出される。 These methods raise an exception if they would write beyond the end of the view.

与えられた型への値の変換は、 型変換の規則 および NaN 値の扱い にて定義される。 Conversions of values to the given type are defined by the type conversion rules and handling of NaN values.

9. ArrayBuffer およびビューの,クローンと転送

Web Workers [WEBWORKERS], との間で、大きなデータを繰り返し転送できるようにするため、 ArrayBuffer Transferable インタフェース [HTML] を実装する。 この節では、 有構造クローン [HTML] ( structured cloning ), および転送アルゴリズムの下での、 ArrayBuffer および ビューのふるまいを定義する。 In order to enable repeated transfer of large amounts of data between Web Workers [WEBWORKERS], ArrayBuffer implements the Transferable interface [HTML]. This section defines the behavior of ArrayBuffers and views under the structured cloning [HTML] and transfer algorithms.

9.1. ArrayBuffer のクローン

利用者エージェントが ArrayBuffer オブジェクト oldクローン するときは、次の手続きを実行して,新たな ArrayBuffer オブジェクトを返さなければならない。 この手続きは不可分的に実行されなければならない。 When a user agent is asked to clone an ArrayBuffer object old, it must run the following steps, which return a new ArrayBuffer object. These steps must be run atomically.

  1. old の下層データの複製を参照し, byteLength プロパティの値が old と同じにされた,新たな ArrayBuffer オブジェクト new buffer を作成する。 Create a new ArrayBuffer object new buffer pointing at a copy of the underlying data from old, and with the same byteLength property.

  2. new buffer を返す(これがクローンである)。 Return new buffer. It is the clone.

9.2. ArrayBuffer の転送

次のものを Transferable 型のリストに追加する。 Add the following to the list of Transferable types:

  • ArrayBuffer ArrayBuffer

ArrayBuffer オブジェクト old転送 [HTML] する際には、利用者エージェントは,次の手続きを実行しなければならない To transfer [HTML] an ArrayBuffer object old, a user agent must run the following steps.

  1. old の下層データの複製を参照し, byteLength プロパティの値が old と同じにされた,新たな ArrayBuffer オブジェクト new buffer を作成する。 Create a new ArrayBuffer object new buffer pointing at the same underlying data as old, and with the same byteLength property.
  2. オブジェクト old無力化 [HTML] する。 Neuter [HTML] object old.
  3. new buffer を返す。 Return new buffer.

9.3. ArrayBufferView のクローン

利用者エージェントが ArrayBufferView オブジェクト oldクローン する必要があるときは、新たなオブジェクトを返す,次の手続きを実行しなければならない。 この手続きは不可分的に実行されなければならない。 When a user agent is asked to clone an ArrayBufferView object old, it must run the following steps, which return a new object. These steps must be run atomically.

  1. buffer :← oldbuffer プロパティに対し 内部的 有構造クローン アルゴリズム internal structured cloning algorithm を再帰的に呼び出した結果とする。 Let buffer be the result of invoking the internal structured cloning algorithm recursively on the buffer property of old.

  2. new view :← 新たに構築された old と同じ型の ArrayBufferView サブクラス。 ここで new view は、 buffer を参照し, old と同じ[ byteOffset, byteLength, サブクラス固有のプロパティすべて ]を伴うものとする。 Let new view be a newly constructed ArrayBufferView subclass of the same type as old, referring to buffer, and with the same byteOffset, byteLength, and any subclass-specific properties as old.

  3. new view を返す(これがクローンである)。 Return new view. It is the clone.

上の節により、次のふるまいが導き出される: The above sections define the following behavior:

  • ArrayBufferpostMessage 呼び出しの下で転送されている場合、その ArrayBuffer を参照し, その呼び出しの間にクローンされた ArrayBufferView インスタンスは、新たに割り当てられた ArrayBuffer オブジェクトを参照する。 postMessage 呼び出しの後、古い ArrayBuffer を参照している ArrayBufferView のインスタンスは,それ以上バッファのデータを参照できなくなる。 それらのインスタンスや古い方の ArrayBuffer に対し,更なるクローンが試行された場合、 DATA_CLONE_ERR 例外が投出されることになる。 If an ArrayBuffer is transferred during a postMessage call, then any ArrayBufferView instances which refer to that ArrayBuffer and which are cloned during that call refer to the newly allocated ArrayBuffer object. After the postMessage call, the ArrayBufferView instances referring to the old ArrayBuffer can no longer be used to reference the buffer's data. Further attempts to clone them or the old ArrayBuffer will cause a DATA_CLONE_ERR exception to be thrown.

  • 転送以外のクローンのふるまいは、 ArrayBuffer および,それを参照するどの ArrayBufferView のインスタンスについても,他の任意のオブジェクト型と同じである。 The behavior of cloning, rather than transferring, an ArrayBuffer and any ArrayBufferView instances which refer to it is the same as for any other object type.

  • 転送可能なのは ArrayBuffer 型のみである。 ArrayBufferView のインスタンスを転送したり、 【転送されているものと】 同じ下層の ArrayBuffer を参照する, ArrayBufferView のインスタンスをクローンすることはできない。 Only the ArrayBuffer type is transferable. It is not possible to transfer certain ArrayBufferView instances, and clone others, if they refer to the same underlying ArrayBuffer.

10. 用例

単純な 128 個の 32-bit float からなる配列を作成: Creating a simple array of 128 32-bit floats:
var f32s = new Float32Array(128);
新たな配列において、 8 個の連続する float ごとに,値をあてがう: Filling each 8 consecutive floats of the new array:
for (var i = 0; i < 128/8; ++i) {
  var sub_f32s = f32s.subarray(i, i+8);
  for (var j = 0; j < 8; ++j) {
    sub_f32s[j] = j;
  }
}

このコードは、 subarray() を利用して,元と同じデータを参照する新たな Float32Array を作成し、どの部分配列も常に 0 〜 7 で index アクセスできるようにする。 Note that this code uses subarray() to create a new Float32Array that references the same data as the original, so that it can always index the sub-array using 0..7.

交替的な配列型

一部の API,特に WebGL [WEBGL] は、異なるデータ型が交替的に繰り返される,単独の連続的バッファが利用可能になることから恩恵を得る。 例えば,1個の point は、1個の座標データ( 3 個の Float32 値)に続いて1個の色データ( 4 個の Uint8 値)を持つ。 Some APIs, in particular WebGL [WEBGL], can benefit from being able to use a single contiguous buffer, with interleaved data types. For example, a point might have coordinate data (3 Float32 values) followed by color data (4 Uint8 values).

4 個の point とそれらに結び付けられた色は、次の様にして設定できる: For 4 points and their associated colors, this can be set up in the following way:

var elementSize = 3 * Float32Array.BYTES_PER_ELEMENT + 4 * Uint8Array.BYTES_PER_ELEMENT;
var buffer = new ArrayBuffer(4 * elementSize);
var coords = new Float32Array(buffer, 0);
var colors = new Uint8Array(buffer, 3 * Float32Array.BYTES_PER_ELEMENT);

しかしながら,型付き配列は、望まれる point 単位の構造へ符号化するための,明示的な方法は備えていない。 したがって、正しく index アクセスするためには,何らかの手作業による算術が必要になる。 Uint8Array ビュー colors は、要素 [0] が下層バッファの 13 番目のバイトを指せるように,(バイト数で与えられる)明示的なオフセットを伴って作成されることに注意。 However, typed arrays don't have a way to explicitly encode the desired per-point structure, so some manual arithmetic must be done to correctly index into the right values. Note that the colors Uint8Array view is created with an explicit offset (which is given in bytes), so that the [0] element points at the 13th byte in the underlying buffer.

この例では、それぞれの ひとまとまりのデータのサイズは, 16 バイトになる( 3 個の 4 バイト float に続く 4 バイト)。 16 ÷ Float32Array.BYTES_PER_ELEMENT = 4 になるので、与えられた Float32 要素から,次の point の同じ Float32 要素へ移動するためには、 index に 4 を加える必要がある。 同様に、与えられた Uint8 要素から,次の point の同じ位置に移動するには、 16 を加える必要がある: In this example, each set of packed data is 16 bytes in size (3 4-byte floats followed by 4 bytes). 16 / Float32Array.BYTES_PER_ELEMENT is 4, so from any given Float32 element, to skip to the same Float32 element in the next point, 4 must be added to the index. Similarly, to skip from any given Uint8 element to the same in the next point, 16 must be added:

var coordOffset = elementSize / Float32Array.BYTES_PER_ELEMENT;
var colorOffset = elementSize / Uint8Array.BYTES_PER_ELEMENT;

coords[0] = coords[1] = coords[2] = 1.0; // 最初の point の 3 個の座標成分値
colors[0] = colors[1] = colors[2] = colors[3] = 255; // 最初の point の 4 個の色成分値

coords[0 + N * coordOffset] = 5.0; // N 番目の point の最初の座標成分値
colors[0 + N * colorOffset] = 128; // N 番目の point の最初の色成分値

coords[i + N * coordOffset] = 6.0; // N 番目の point の i 番目の座標成分値
colors[j + N * colorOffset] = 200; // N 番目の point の j 番目の色成分値

上の例でデータの一貫性が保たれるためには、 i は 0, 1, 2 のいずれか, j は 0, 1, 2, 3 のいずれか,でなければならないことに注意。 値がそれを超えると、 32-bit float や 8-bit integer に用意されたデータ区分が不正なデータで上書きされることになる。 In the above example, note that for keeping the data consistent, i must be one of 0, 1, or 2; and j must be one of 0, 1, 2, or 3. Any higher values will result in data segments that are reserved for 32-bit floats or for 8-bit integers being overwritten with incorrect data.

大きな配列から複数の部分域を切り出す Slicing a large array into multiple regions

上のものに似た他の利用として、1個の大きなバッファを割り当てた上で,様々な目的で異なる区域を利用する: Another usage similar to the above is allocating one large buffer, and then using different regions of it for different purposes:

var buffer = new ArrayBuffer(1024);

サイズ 128 × 4 = 512 バイトの 128 個の float を切り出す: Carve out 128 floats, 128*4 = 512 bytes in size:

var floats = new Float32Array(buffer, 0, 128);

しかる後、 floats の直後から,サイズ 128 × 2 = 256 バイトの 128 個の short を切り出す。 バイトオフセット引数 512 は、 floats.byteOffset + floats.byteLength に等しいことに注意。 Then 128 shorts, 128*2 = 256 bytes in size, immediately following the floats. Note that the 512 byte offset argument is equal to floats.byteOffset + floats.byteLength.

var shorts = new Uint16Array(buffer, 512, 128);

最後に、 256 個の符号なしバイトを切り出す。 バイトオフセットを先に示したやり方で書けば、連鎖も単純になる。 長さを省略すれば、配列は ArrayBuffer の終端まで延長される。 Finally, 256 unsigned bytes. We can write the byte offset in the form suggested above to simplify the chaining. We also let this array extend until the end of the ArrayBuffer by not explicitly specifying a length.

var bytes = new Uint8Array(buffer, shorts.byteOffset + shorts.byteLength);

データがそれ以上必要とされなくなった際には、単に古いビューを破棄して, 新たなビューを作成することにより,追加の割り当て(この例では全体で 1024 バイト)を要せずに配列を再利用できる。 If the data is no longer needed, the entire 1024-byte array can be repurposed without causing additional allocations simply by creating new views and discarding the old.

11. 解決済みの論点

DataView は、データの配列を読み取るためのメソッドを持つべきか? Should DataView have methods for reading arrays of data?

その種のメソッドは有用ではあるが、 API を小さく保つため,このバージョンの仕様には取り入れられない。 その種のメソッドは将来に委ねられる。 While such methods would be useful, they are not present in this version of the specification to reduce the API footprint. Such methods may be added in the future.

12. 参照文献

[ECMA-262]
ECMAScript Language Specification, 5th Edition, P. Lakshman and A. Wirfs-Brock, Editors. Ecma International, December 2009. Available at http://www.ecma-international.org/publications/standards/Ecma-262.htm.
[FILEAPI]
File API, A. Ranganathan, J. Sicking. W3C.
[HTML]
HTML, I. Hickson. WHATWG.
[IEEE-754]
IEEE Standard for Binary Floating-Point Arithmetic (ANSI/IEEE Std 754-1985). Institute of Electrical and Electronics Engineers, 1985.
[WEBGL]
WebGL Specification, C. Marrin. Khronos.
[WEBIDL]
Web IDL, C. McCormack. W3C.
[WEBMESSAGING]
Web Messaging, I. Hickson. WHATWG.
[WEBSOCKETS]
The WebSocket API, I. Hickson. W3C.
[WEBWORKERS]
Web Workers, I. Hickson. WHATWG.
[XMLHTTPREQUEST]
XMLHttpRequest, A. Kesteren. WHATWG.

13. 謝辞

編集者は、この仕様に寄与された次の方々と WebGL working group のメンバの方々に感謝する:

The editors would like to thank Erik Arvidsson (Google), Joshua Bell (Linden Lab), Mark Callow (HI), Brendan Eich (Mozilla), Andreas Gal (Mozilla), Daniel Gessel (Apple), Dave Herman (Mozilla), Oliver Hunt (Apple), Tim Johansson (Opera), Vangelis Kokkevis (Google), Chris Marrin (Apple), Glenn Maynard, Cameron McCormack, Shiki Okasaka (Google), Arun Ranganathan (Mozilla), Alex Russell (Google), Gregg Tavares (Google), Ben Vanik (Google), Cedric Vivier (Mozilla), and the members of the WebGL working group for their contributions to this specification.

編集者は、この仕様の以前のバージョンで協同して編集を行った Vladimir Vukicevic に特に感謝する。 The editors would especially like to thank Vladimir Vukicevic for co-editing earlier versions of this specification.