Bem, na verdade é um objeto, por exemplo, podemos criar uma matriz como esta:
var array = nova matriz (10);
O poder e a onipotência das matrizes JavaScript nos trazem conveniência. Mas de um modo geral:
Coisas completas podem ser usadas em vários ambientes, mas não são necessariamente adequadas para vários ambientes.
TypeDArray é precisamente o que aconteceu para resolver o problema de que as matrizes fazem muitas coisas em JavaScript.
origemO TypeDArray é um tipo de buffer de comprimento fixo comum que permite a leitura de dados binários no buffer.
É introduzido na especificação WebGL para resolver o problema dos dados binários de processamento de JavaScript.
TypeDArray foi apoiado pela maioria dos navegadores modernos. Por exemplo, você pode criar typeDArray usando o seguinte método:
// Crie uma matriz de 8 bytes
var B = novo ArrayBuffer (8);
// Crie uma referência de B, tipo Int32, a posição inicial é 0 e a posição final é o final do buffer
var v1 = new int32Array (b);
// Crie uma referência de B, o tipo é UINT8, a posição inicial é 2 e a posição final é o fim do buffer
var v2 = novo uint8Array (b, 2);
// Crie uma referência de B, tipo Int16, a posição inicial é 2 e o comprimento total é 2
var v3 = novo int16Array (b, 2, 2);
O layout de referência em buffer e criado é:
| variável | índice | |||||||
|---|---|---|---|---|---|---|---|---|
| Número de bytes | ||||||||
| b = | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 |
| Número de índices | ||||||||
| v1 = | 0 | 1 | ||||||
| v2 = | 0 | 1 | 2 | 3 | 4 | 5 | ||
| v3 = | 0 | 1 | ||||||
Isso significa que o 0º elemento da matriz V1 do tipo Int32 é o 0-3 bytes do Type ArrayBuffer e assim por diante.
ConstrutorAcima, criamos o TypeDArray através do ArrayBuffer e, de fato, o TypeDArray fornece 3 construtores para criar sua instância.
TypeDArray (comprimento longo não assinado)
Crie um novo typedArray com o comprimento sendo o seu comprimento fixo.
TypedArray (matriz typeDArray)
TypeDArray (matriz do tipo []
Crie um novo typeDArray, cada elemento é inicializado de acordo com a matriz e o elemento é convertido de acordo.
TypeDArray (Buffer de ArrayBuffer, Opcional não assinado Byteoffset, comprimento longo não assinado opcional)
Crie um novo TypeDArray como uma referência ao buffer, byteoffset como deslocamento de partida e comprimento como seu comprimento.
Por isso, geralmente criamos o TypeDArray da seguinte maneira:
var Array = novo UINT8Array (10);
ou:
var Array = novo UINT8Array ([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
Operação de dadosO typeDArray fornece quatro métodos: setter, getter, conjunto e subarray para operações de dados.
Retorna o elemento do índice especificado.
Conjunto de Void Setter (índice longo não assinado, valor de tipo )Defina o elemento do índice especificado para o valor especificado.
Conjunto de void (matriz typeDArray , deslocamento de deslocamento longo não assinado opcional) ( Tipo [] Matriz , deslocamento longo não assinado opcional)Defina o valor de acordo com a matriz, o deslocamento é a posição de deslocamento.
Subarray typeDArray (Long Inict, Long End Opcional)Retorna um novo TypeDArray com o bit de início começar e o final final.
Por exemplo, os elementos de leitura podem ser usados : var Array = novo uint8array ([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]); alerta (matriz [4]); // 5 Elementos de configuração podem ser usados : var Array = novo uint8array ([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]); alerta (matriz [4]); // 5Array [4] = 12; Alert (Array [4]); // 12 Obtenha uma cópia e você pode usar : var Array = novo UINT8Array ([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]); var Array2 = Array.subarray (0); Tipo de matriz| tipo | tamanho | descrever | Tipo IDL da Web | Tipo c |
|---|---|---|---|---|
Int8Array | 1 | Inteiro assinado de 8 bits | byte | signed char |
Uint8Array | 1 | Inteiro não assinado de 8 bits | octet | unsigned char |
Uint8ClampedArray | 1 | Inteiro não assinado de 8 bits (preso) | octet | unsigned char |
Int16Array | 2 | Inteiro assinado de 16 bits | short | short |
Uint16Array | 2 | Inteiro não assinado de 16 bits | unsigned short | unsigned short |
Int32Array | 4 | Inteiro assinado de 32 bits | long | int |
Uint32Array | 4 | Inteiro não assinado de 32 bits | unsigned long | unsigned int |
Float32Array | 4 | Número de ponto flutuante IEEE de 32 bits | unrestricted float | float |
Float64Array | 8 | Número de ponto flutuante IEEE de 64 bits | unrestricted double | double |
Aqueles que tocaram em tela podem parecer familiares.
Porque a matriz usada no Imagagata para armazenar dados de imagem é do tipo uint8clampedArray.
Por exemplo:
var context = document.createElement (canvas) .getContext (2d); var imagedata = context.createImagedata (100, 100); console.log (imagedata.data); É exibido no Firebug como :Por que usar typeDArrayUINT8ClampedArray {0 = 0, 1 = 0, 2 = 0, mais ...}
Sabemos que os números no JavaScript são números de ponto flutuante de 64 bits. Para uma imagem binária (cada pixel é armazenado como um número inteiro não assinado de 8 bits), se você deseja usar seus dados em uma matriz JavaScript, é equivalente a usar 8 vezes a memória da imagem para armazenar os dados de uma imagem, o que é obviamente não científico. O typeDArray pode nos ajudar a usar apenas 1/8 da memória original para armazenar dados de imagem.
Ou para o WebSocket, também é uma maneira mais cara de se transferir com o Base64, e a mudança para a transferência binária pode ser uma maneira melhor.
Obviamente, o TypeDArray tem mais benefícios, como ter um melhor desempenho. Vamos fazer alguns pequenos testes para verificar isso.
Os navegadores que participam do teste são :TEST1: leitura de leitura sequencial LeituraFirefox 17.0.1 e Chrome 23.0.1271.97M
var timeArray1 = [];
var timeArray2 = [];
função check1 () {
var Array = novo 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 = matriz [i];
}
var time2 = (new Date ()). getTime ();
console.log (TIME2 - TIME1);
timeArray1.push (time2 - time1);
}
função check2 () {
var array2 = nova matriz (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);
}
Timer de função (__ Fun, __time, __callback) {
var agora = 0;
função begin () {
var timeout = setTimeout (function () {
if (agora! == __time) {
agora ++;
__diversão();
começar();
}outro{
if (timearray1.length && timearray2.length) {
console.log ("timearray1 ==" + timearray1 + ", média ==" + média (timearray1));
console.log ("timearray2 ==" + timearray2 + ", média ==" + média (timearray2));
}
__callback && __callback ();
}
}, 100);
}
começar();
}
Média da função (__ Array) {
var total = 0;
for (var i = __array.length; i-;) {
total += __array [i];
}
return (total / __array.length);
}
Timer (Check1, 10, function () {
timer (check2, 10);
});
Pode -se observar que a velocidade de leitura do UINT8ClampedArray é significativamente mais rápida que a da matriz (quanto mais a barra, mais tempo leva).
Test2: Leia aleatória//…
função check1 () {
var Array = novo 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);
}
função check2 () {
var array2 = nova matriz (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);
}
//…
O UINT8ClampedArray lê mais rápido que o Array.
Test3: escrita sequencial//…
função check1 () {
var Array = novo 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);
}
função check2 () {
var array2 = nova matriz (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: Operação de cópia (U8C para U8C e Array para U8C)//…
função check1 () {
var Array = novo UINT8ClampedArray (5000000);
for (var i = array.length; i-;) {
Array [i] = Math.floor (Math.random () * 100);
}
var temp;
var Array2 = novo UINT8ClampedArray (5000000);
var time1 = (new Date ()). getTime ();
Array2.set (Array);
var time2 = (new Date ()). getTime ();
console.log (TIME2 - TIME1);
timearray2.push (time2 - time1);
}
função check2 () {
var array = nova matriz (5000000);
for (var i = array.length; i-;) {
Array [i] = Math.floor (Math.random () * 100);
}
var temp;
var Array2 = novo UINT8ClampedArray (5000000);
var time1 = (new Date ()). getTime ();
Array2.set (Array);
var time2 = (new Date ()). getTime ();
console.log (TIME2 - TIME1);
timearray2.push (time2 - time1);
}
//…
Pode -se observar que copiar U8C para U8C é muito mais rápido do que copiar a matriz do U8C.