Arrays in Javascript are powerful. The powerful and all-powerful arrays in Javascript bring us convenience, typedArray is designed to solve the problem of "too many things" In arrays in Javascript ....,. Arrays in Javascript are powerful guys:
- You can dynamically change the length instead of specifying the length during creation.
- You can read it as a normal array or use it as a stack.
- You can change the value or type of each element in the array.
Well, it is actually an object. For example, we can create an array like this:
var array = new Array(10);
The powerful and omnipotent array of Javascript brings us convenience. But in general:
All-powerful things can be used in various environments, but they are not necessarily applicable to various environments.
TypedArray is designed to solve the problem of "too many tasks" in arrays in Javascript.
Origin
TypedArray is a common fixed-length buffer type that allows reading binary data in the buffer.
It is introduced in the WEBGL specification to solve the problem of Javascript processing binary data.
TypedArray has been supported by most modern browsers. For example, you can use the following method to create TypedArray:
// Create an 8-byte ArrayBuffer var B = new ArrayBuffer (8); // create a reference to B. The type is Int32 and the start position is 0, the end position is var v1 = new Int32Array (B) at the end of the buffer; // create a reference to B. The type is Uint8 and the start position is 2, the end position is the var v2 = new Uint8Array (B, 2) at the end of the buffer. // create a reference for B. The type is Int16 and the start position is 2, the total length is 2 var v3 = new Int16Array (B, 2, 2 );
The buffer and reference layout are as follows:
| Variable |
Index |
|
Bytes |
| B = |
0 |
1 |
2 |
3 |
4 |
5 |
6 |
7 |
|
Number of Indexes |
| V1 = |
0 |
1 |
| V2 = |
|
0 |
1 |
2 |
3 |
4 |
5 |
| V3 = |
|
0 |
1 |
|
This indicates that the 0th elements of the v1 array of the Int32 type are the 0-3 bytes of the B of the ArrayBuffer type.
Constructor
We used ArrayBuffer to create TypedArray. In fact, TypedArray provides three constructors to create its instances.
| Constructor |
-
TypedArray(Unsigned long length)
-
Create a new TypedArray with a fixed length.
|
-
TypedArray( TypedArrayArray)
-
TypedArray( Type[] Array)
-
Create a new TypedArray. Each element is initialized according to the array, and the elements undergo corresponding type conversion.
|
-
TypedArray(ArrayBuffer buffer, optional unsigned long byteOffset, optional unsigned long length)
-
Create a new TypedArray as a buffer reference. byteOffset is the starting offset and length is the length.
|
Therefore, we usually use the following method to create TypedArray:
var array = new Uint8Array(10);
Or:
var array = new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
Data Operations
TypedArray provides the setter, getter, set, and subarray methods for data operations.
| Method |
-
Getter TypeGet (unsigned long index)
-
Returns the element of the specified index.
|
-
Setter void set (unsigned long index, TypeValue)
-
Set the element of the specified index to the specified value.
|
-
Void Set( TypedArrayArray, optional unsigned long offset)
-
Void Set( Type[] Array, optional unsigned long offset)
-
Set the offset Value Based on array.
|
-
TypedArray Subarray(Long begin, optional long end)
-
A new TypedArray is returned. The start bit is begin and the last bit is end.
|
For example, you can use:
var array = new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);alert(array[4]); //5
The setting element can be used:
var array = new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);alert(array[4]); //5array[4] = 12;alert(array[4]); //12
To obtain a copy, you can use:
var array = new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);var array2 = array.subarray(0);
Array type
| Type |
Size |
Description |
Web IDL type |
C type |
Int8Array |
1 |
8-bit signed integer |
byte |
signed char |
Uint8Array |
1 |
8-bit unsigned integer |
octet |
unsigned char |
Uint8ClampedArray |
1 |
8-bit unsigned integer (clamped) |
octet |
unsigned char |
Int16Array |
2 |
16-bit signed integer |
short |
short |
Uint16Array |
2 |
16-bit unsigned integer |
unsigned short |
unsigned short |
Int32Array |
4 |
32-bit signed integer |
long |
int |
Uint32Array |
4 |
32-bit unsigned integer |
unsigned long |
unsigned int |
Float32Array |
4 |
32-bit IEEE floating point number |
unrestricted float |
float |
Float64Array |
8 |
64-bit IEEE floating point number |
unrestricted double |
double |
You may find yourself familiar with canvas.
The array used to store image data in ImageData is of the Uint8ClampedArray type.
For example:
var context = document.createElement("canvas").getContext("2d");var imageData = context.createImageData(100, 100);console.log(imageData.data);
It is shown in FireBug:
Uint8ClampedArray {0 = 0, 1 = 0, 2 = 0, more ...}
Why TypedArray?
We know that the number in Javascript is a 64-bit floating point number. For a binary image (each pixel in the image is stored in an 8-bit unsigned integer), if you want to use the data in the Javascript array, it is equivalent to using 8 times the memory of the image to store the data of an image, which is obviously unscientific. TypedArray helps us store image data with only 1/8 of the original memory.
Or for WebSocket, if base64 is used for transmission, it is also a high-cost method. Instead, binary transmission may be better.
Of course, TypedArray has more benefits, such as better performance. Next we will perform some small tests to verify this.
The browser involved in the test is:
FireFox 17.0.1 and Chrome 23.0.20.1.97m
- Test1: sequential read Speed
var timeArray1 = [];var timeArray2 = [];function check1(){ var array = new Uint8ClampedArray(5000000); for(var i = array.length; i--;){ array[i] = Math.floor(Math.random() * 100); } var temp; var time1 = (new Date()).getTime(); for(var i = array.length; i--;){ temp = array[i]; } var time2 = (new Date()).getTime(); console.log(time2 - time1); timeArray1.push(time2 - time1);}function check2(){ var array2 = new Array(5000000); for(var i = array2.length; i--;){ array2[i] = Math.floor(Math.random() * 100); } var temp; var time3 = (new Date()).getTime(); for(var i = array2.length; i--;){ temp = array2[i]; } var time4 = (new Date()).getTime(); console.log(time4 - time3); timeArray2.push(time4 - time3);}function timer(__fun, __time, __callback){ var now = 0; function begin(){ var timeout = setTimeout(function(){ if(now !== __time){ now++; __fun(); begin(); }else{ if(timeArray1.length && timeArray2.length){ console.log("timeArray1 == " + timeArray1 + ", average == " + average(timeArray1)); console.log("timeArray2 == " + timeArray2 + ", average == " + average(timeArray2)); } __callback && __callback(); } }, 100); } begin();}function average(__array){ var total = 0; for(var i = __array.length; i--;){ total += __array[i]; } return (total / __array.length);}timer(check1, 10, function(){ timer(check2, 10);});
It can be seen that the read Speed of Uint8ClampedArray is significantly faster than that of Array (the longer the bar, the more time it takes ).
//……function check1(){ var array = new Uint8ClampedArray(5000000); for(var i = array.length; i--;){ array[i] = Math.floor(Math.random() * 100); } var temp; var time1 = (new Date()).getTime(); for(var i = array.length; i--;){ temp = array[Math.floor(Math.random() * 5000000)]; } var time2 = (new Date()).getTime(); console.log(time2 - time1); timeArray1.push(time2 - time1);}function check2(){ var array2 = new Array(5000000); for(var i = array2.length; i--;){ array2[i] = Math.floor(Math.random() * 100); } var temp; var time3 = (new Date()).getTime(); for(var i = array2.length; i--;){ temp = array2[Math.floor(Math.random() * 5000000)]; } var time4 = (new Date()).getTime(); console.log(time4 - time3); timeArray2.push(time4 - time3);}//……
The Uint8ClampedArray read speed is faster than that of Array.
//……function check1(){ var array = new Uint8ClampedArray(5000000); var time1 = (new Date()).getTime(); for(var i = array.length; i--;){ array[i] = Math.floor(Math.random() * 100); } var time2 = (new Date()).getTime(); console.log(time2 - time1); timeArray1.push(time2 - time1);}function check2(){ var array2 = new Array(5000000); var time3 = (new Date()).getTime(); for(var i = array2.length; i--;){ array2[i] = Math.floor(Math.random() * 100); } var time4 = (new Date()).getTime(); console.log(time4 - time3); timeArray2.push(time4 - time3);}//……
- Test4: copy operation (U8C to U8C and Array to U8C)
//……function check1(){ var array = new Uint8ClampedArray(5000000); for(var i = array.length; i--;){ array[i] = Math.floor(Math.random() * 100); } var temp; var array2 = new Uint8ClampedArray(5000000); var time1 = (new Date()).getTime(); array2.set(array); var time2 = (new Date()).getTime(); console.log(time2 - time1); timeArray2.push(time2 - time1);}function check2(){ var array = new Array(5000000); for(var i = array.length; i--;){ array[i] = Math.floor(Math.random() * 100); } var temp; var array2 = new Uint8ClampedArray(5000000); var time1 = (new Date()).getTime(); array2.set(array); var time2 = (new Date()).getTime(); console.log(time2 - time1); timeArray2.push(time2 - time1);}//……
It can be seen that copying U8C to U8C is much faster than copying Array to U8C.
References
Typed Array Specification