Acredito que todo aluno JavaScript entenderá vários tipos de dados básicos de JS. Matrizes são combinações de dados. Este é um conceito muito básico e simples. Não tem muito conteúdo e não é difícil aprender bem. Mas o que é importante neste artigo não é a matriz que geralmente vemos, mas o ArrayBuffer.
Muitas das coisas que escrevi estão deliberadamente resumidas porque desejam concluir certas funções específicas. Eles podem ser considerados memorandos, e o mesmo se aplica a este artigo! Eu tenho estudado o conhecimento relacionado à API de áudio da Web e à comunicação de voz há algum tempo. O conteúdo se concentra no fluxo de fluxos de áudio entre vários nós do Audiocontext. Agora eu preciso entender que tipo de formato de dados é o áudio para o fluxo, então a pesquisa no ArrayBuffer é particularmente importante.
Modelo de pilha de matriz na memória
Aquisição da Array
Como gerar matriz em JavaScript:
A cópia do código é a seguinte:
[Element0, Element1, ..., Elementn]
nova matriz (element0, element1, ..., elementn)
Nova matriz (ArrayLength)
Defina -o diretamente ou crie uma matriz através do construtor, é claro, você também pode usar outros meios:
A cópia do código é a seguinte:
"Array" .split ("");
"Array" .match (/a | r/g);
Espere, existem muitas maneiras. Mas receio que muitas pessoas não estejam muito claras sobre que tipo de estrutura a matriz está dentro.
Modelo de pilha
Na matriz, podemos colocar muitos dados de diferentes tipos de dados, como:
A cópia do código é a seguinte:
var arr = [21, "li jing", new date (), function () {} ,, null];
A matriz acima contém números, cordas, objetos, funções, indefinidos e nulos de uma só vez. Podemos descrever a interface de dados acima de uma maneira concreta:
A cópia do código é a seguinte:
Pilha
+------------------------------------------------------------------------------------------------------------------------------------------------------
| 21 | +-----------------------------+
+ ----------+ | |
| "Li Jing" | | |
+ ----------+ | + ---------+ |
| [consulte] | -----------> | Objeto | |
+ ----------+ | + ---------+ |
| [consulte] | ------------------>+ ---------+ |
+ ----------+ | | função | |
| indefinido | | + ---------+ |
+ ----------+ | |
| nulo | +---------------------------+
+ -------------+ Criado por Barret Lee
Os tipos de dados JavaScript são divididos em dois tipos, um é o tipo de valor e o outro é o tipo de referência. Os tipos de referência comuns incluem objeto e matriz. No modelo de armazenamento da matriz, se os dados do tipo de valor forem como número e string, os dados serão pressionados diretamente para a pilha, enquanto o tipo de referência será pressionado apenas para um índice do valor. O conceito de linguagem C é salvar apenas o ponteiro dos dados, e esses dados são armazenados em um determinado bloco da pilha. A pilha não é independente e a pilha também pode ser armazenada na pilha.
Ok, isso é tudo para a explicação da matriz. Vamos falar sobre o conhecimento relevante do ArrayBuffer em detalhes.
ArrayBuffer
O que é a web? Qual é a questão mais básica que a web precisa discutir? Eu acho que há dois pontos: um é dados e o outro é a transmissão de dados. Quanto à exibição de dados, ele é complicado e isso deve ser algo na camada superior da web. O ArrayBuffer a ser discutido neste artigo é o tipo de dados mais básico e não pode ser chamado de tipo de dados. É fácil ler e escrever de outras maneiras.
Definição de pontos oficiais:
O ArrayBuffer é um tipo de dados usado para representar um buffer de dados binários genéricos de comprimento fixo. Você não pode manipular diretamente o conteúdo de um matriz; Em vez disso, você cria um objeto ArrayBufferView que representa o buffer em um formato específico e usa -o para ler e escrever o conteúdo do buffer.
O buffer original representando dados binários, que são usados para armazenar dados de vários tipos de matrizes. O ArrayBuffer não pode ser lido ou escrito diretamente, mas pode ser passado para um objeto de matriz digitado ou dataView conforme necessário para interpretar o buffer original.
É um buffer bruto de dados binários. Embora o JavaScript seja um idioma do tipo fraco, ele próprio tem limitações no tipo e tamanho dos dados. Precisamos ler o conteúdo do buffer de maneira ordenada (escreva -o) através de uma determinada estrutura de dados.
Criação de buffer original
O construtor ArrayBuffer pode criar um buffer cru:
A cópia do código é a seguinte:
var buffer = new ArrayBuffer (30);
Do console do Chrome, você pode ver:
A instância do buffer possui um atributo de comprimento, usado para obter o tamanho do buffer, um método de fatia que é suportado apenas pelo IE11+ e iOS6+, que é usado para interceptar o comprimento do buffer.
A cópia do código é a seguinte:
Fatia de ArrayBuffer (
Não assinado Long Begin
não assinado de ponta longa opcional
);
Você pode testar esta demonstração:
A cópia do código é a seguinte:
var buffer = new ArrayBuffer (12);
var x = novo int32Array (buffer);
x [1] = 1234;
var slice = buffer.slice (4);
var y = novo int32Array (slice);
console.log (x [1]);
console.log (y [0]);
x [1] = 6789;
console.log (x [1]);
console.log (y [0]);
Matrizes baseadas em dados
Os tipos de matriz digitados representam várias visualizações de objetos de ArrayBuffer indexable e manipulados. Todos os tipos de matriz têm comprimentos fixos.
A cópia do código é a seguinte:
Tamanho do nome (em bytes) Descrição
INT8Array 1 de 8 bits Two Complement assinado inteiro
UINT8Array 1 Inteiro não assinado de 8 bits
Int16Array 2 de 16 bits dois do complemento assinado inteiro
UINT16Array 2 Inteiro não assinado de 16 bits
INT32Array 4 Inteiro assinado de dois de 32 bits
UINT32Array 4 inteiro não assinado de 32 bits
Float32Array 4 Número de ponto flutuante IEEE de 32 bits
Float64Array 8 Número de ponto flutuante IEEE IEEE de 64 bits
Int é um número inteiro, o UINT é um plástico não assinado e o float é do tipo de ponto flutuante. Esses são os conceitos básicos na linguagem C, por isso não os explicarei em detalhes. Como essas estruturas visualizadas são semelhantes, este artigo explica apenas o tipo Float32Array, e os leitores podem aprender com ele um por um.
O float32Array é muito semelhante ao Array, exceto que cada elemento é dados de ponto flutuante de 32 bits (4 bytes). Float32Array uma vez criado, seu tamanho não pode ser modificado.
Podemos criar um float32Array diretamente:
A cópia do código é a seguinte:
var x = novo float32Array (2);
x [0] = 17;
console.log (x [0]); // 17
console.log (x [1]); // 0
console.log (x.length); // 2
É preciso haver um conceito de que ainda é uma matriz, mas cada elemento na matriz é um tipo de dados de 32 bits, por exemplo:
A cópia do código é a seguinte:
var x = novo float32Array ([17, -45.3]);
console.log (x [0]); // 17
console.log (x [1]); // -45.2999923706055
console.log (x.length); // 2
Atribuímos o valor de uma matriz diretamente a X, o objeto Float32Array e, em seguida, será convertido em um número de ponto flutuante de 32 bits antes do armazenamento.
Como cada elemento dessa matriz de classe é do mesmo tipo, no modelo de pilha, todos serão empurrados para a pilha. Portanto, a matriz dados dados é um tipo de valor e não é um tipo de referência! Isso deve ser notado e também pode ser refletido nos seguintes exemplos:
A cópia do código é a seguinte:
var x = novo float32Array ([17, -45.3]);
var y = novo float32Array (x);
console.log (x [0]); // 17
console.log (x [1]); //-45.29999923706055
console.log (x.length); // 2
x [0] = -2;
console.log (y [0]); // 17, o valor de y não mudou
Copie o valor de x para y, modifique x [0], y [0] e não há alteração.
Além do método acima, também podemos criar uma matriz dados de outras maneiras:
A cópia do código é a seguinte:
var buffer = new ArrayBuffer (12);
var x = novo float32Array (buffer, 0, 2);
var y = novo float32Array (buffer, 4, 1);
x [1] = 7;
console.log (y [0]); // 7
Explique por que 7 é devolvido aqui.
A cópia do código é a seguinte:
ArrayBuffer (12)
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | | | | | |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
/ / /
x (float32Array)
deslocamento: 0
BYTEL LIMNOTE: 4
Comprimento: 2
ArrayBuffer (12)
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | | | | | |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
/ / /
y
Criado por Barret Lee
Você ainda tem alguma dúvida depois de ler a ilustração acima? Acho que não preciso continuar explicando. A unidade de ArrayBuffer pode ser considerada 1, enquanto a unidade do float32Array é 4.
Objeto DataView
O objeto DataView opera dados mais meticulosamente, mas não acho interessante. As várias matrizes baseadas em dados mencionadas acima podem basicamente satisfazer o aplicativo, então vou mencioná-lo aqui, um exemplo simples:
A cópia do código é a seguinte:
var buffer = new ArrayBuffer (12);
var x = new DataView (buffer, 0);
x.setInt8 (0, 22);
x.setFloat32 (1, Math.pi);
console.log (x.getInt8 (0)); // 22
console.log (x.getfloat32 (1)); // 3.1415927410125732
Se você estiver interessado, poderá passar para http://www.javascripture.com/dataview para obter informações detalhadas.
ArrayBuffer em Xhr2
ArrayBuffer é particularmente amplamente utilizado. Seja WebSocket, Webudio, Ajax, etc., desde que o Big Data do processo front-end ou deseje melhorar o desempenho do processamento de dados, o ArrayBuffer deve ser indispensável.
XHR2 não é novo. Você pode ter usado recursos relevantes, mas não sabe que é isso que o XHR2 é. O mais importante é o XHR.SponseType, que é usado para definir o formato de dados da resposta. Os parâmetros opcionais são: "Texto", "ArrayBuffer", "Blob" ou "Document". Observe que a configuração (ou ignorando) XHR.ResponseType = '' definirá a resposta como "texto" por padrão. Existe um relacionamento correspondente como este:
A cópia do código é a seguinte:
Solicitar resposta
Domstring de texto
ArrayBuffer ArrayBuffer
Blob Blob
documento documento
Pegue uma castanha:
A cópia do código é a seguinte:
var xhr = novo xmlHttPrequest ();
xhr.open ('get', '/path/to/image.png', true);
xhr.ResponseType = 'ArrayBuffer';
xhr.onload = function (e) {
// this.Response == UINT8Array.Buffer
var uint8Array = novo uint8Array (this.Response);
};
xhr.send ();
Definimos a propriedade para ArrayBuffer em Xhr.PronseType, para que possamos usar uma matriz baseada em dados para aceitar os dados que obtemos!
resumo
Este artigo apresenta principalmente como a matriz é armazenada no modelo de pilha e também descreve em detalhes o tipo de dados binário do ArrayBuffer, o buffer original. No desenvolvimento da Web, os dados e o armazenamento de dados são uma parte importante, espero atrair atenção!
Pode haver erros na narrativa deste artigo, corrija -os mais!