Como converter um buffer binário do NodeJS em um JavaScript ArrayBuffer?

Instâncias de Buffertambém são instânciasUint8Array no node.js 4.xe superior. Portanto, a solução mais eficiente é acessar a buf.bufferpropriedade diretamente, conforme https://stackoverflow.com/a/31394257/1375574 . O construtor Buffer também aceita um argumento ArrayBufferView se você precisar ir na outra direção.

Observe que isso não criará uma cópia, o que significa que as gravações em qualquer ArrayBufferView serão gravadas na instância original do Buffer.

Do buffer para o ArrayBuffer:

function toArrayBuffer(buf) {
    var ab = new ArrayBuffer(buf.length);
    var view = new Uint8Array(ab);
    for (var i = 0; i < buf.length; ++i) {
        view[i] = buf[i];
    }
    return ab;
}

De ArrayBuffer para Buffer:

function toBuffer(ab) {
    var buf = Buffer.alloc(ab.byteLength);
    var view = new Uint8Array(ab);
    for (var i = 0; i < buf.length; ++i) {
        buf[i] = view[i];
    }
    return buf;
}

Sem dependências, mais rápido, Node.js 4.xe posterior

Buffers são Uint8Arrays, então você só precisa cortar (copiar) sua região do suporte ArrayBuffer.

// Original Buffer
let b = Buffer.alloc(512);
// Slice (copy) its segment of the underlying ArrayBuffer
let ab = b.buffer.slice(b.byteOffset, b.byteOffset + b.byteLength);

O slicematerial e offset são necessários porque Buffers pequenos (menos de 4 kB por padrão, metade do tamanho do pool ) podem ser vistas em um compartilhamento ArrayBuffer. Sem fatiar, você pode acabar com um ArrayBufferdado contendo outro Buffer. Veja a explicação nos documentos .

Se você precisar de um TypedArray, poderá criar um sem copiar os dados:

// Create a new view of the ArrayBuffer without copying
let ui32 = new Uint32Array(b.buffer, b.byteOffset, b.byteLength / Uint32Array.BYTES_PER_ELEMENT);

Sem dependências, velocidade moderada, qualquer versão do Node.js

Use a resposta de Martin Thomson , que é executada em O (n) tempo. (Veja também minhas respostas aos comentários sobre a resposta dele sobre não otimizações. O uso de um DataView é lento. Mesmo se você precisar inverter bytes, existem maneiras mais rápidas de fazer isso.)

Dependência, rápida, Node.js ≤ 0.12 ou iojs 3.x

Você pode usar https://www.npmjs.com/package/memcpy para ir em qualquer direção (Buffer para ArrayBuffer e vice-versa). É mais rápido que as outras respostas postadas aqui e é uma biblioteca bem escrita. O nó 0.12 a iojs 3.x requer o fork do ngossen (consulte isso ).

"De ArrayBuffer para Buffer" pode ser feito desta maneira:

var buffer = Buffer.from( new Uint8Array(ab) );

Uma maneira mais rápida de escrever

var arrayBuffer = new Uint8Array(nodeBuffer).buffer;

No entanto, isso parece ser executado aproximadamente quatro vezes mais lento que a função toArrayBuffer sugerida em um buffer com 1024 elementos.

1. A Bufferé apenas uma visão para analisar um ArrayBuffer.

A Buffer, de fato, é a FastBuffer, que extends(herda de) Uint8Array, que é uma visão da unidade de octetos ("acessador parcial") da memória real, an ArrayBuffer.

class FastBuffer extends Uint8Array {
  constructor(arg1, arg2, arg3) {
    super(arg1, arg2, arg3);
  }
}
FastBuffer.prototype.constructor = Buffer;
internalBuffer.FastBuffer = FastBuffer;

Buffer.prototype = FastBuffer.prototype;

2. O tamanho de um ArrayBuffere o tamanho de sua visualização podem variar.

Razão # 1: Buffer.from(arrayBuffer[, byteOffset[, length]]).

Com Buffer.from(arrayBuffer[, byteOffset[, length]]), você pode criar um Buffercom especificando sua posição subjacente ArrayBuffere a posição e tamanho da exibição.

const test_buffer = Buffer.from(new ArrayBuffer(50), 40, 10);
console.info(test_buffer.buffer.byteLength); // 50; the size of the memory.
console.info(test_buffer.length); // 10; the size of the view.

Razão # 2: FastBufferalocação de memória.

Ele aloca a memória de duas maneiras diferentes, dependendo do tamanho.

• Se o tamanho for menor que a metade do tamanho de um conjunto de memórias e não for 0 (“pequeno”) : ele utiliza um conjunto de memórias para preparar a memória necessária.
• Senão : ele cria um dedicado ArrayBufferque se encaixa exatamente na memória necessária.

function allocate(size) {
  if (size <= 0) {
    return new FastBuffer();
  }
  if (size < (Buffer.poolSize >>> 1)) {
    if (size > (poolSize - poolOffset))
      createPool();
    var b = new FastBuffer(allocPool, poolOffset, size);
    poolOffset += size;
    alignPool();
    return b;
  } else {
    return createUnsafeBuffer(size);
  }
}

function createUnsafeBuffer(size) {
  return new FastBuffer(createUnsafeArrayBuffer(size));
}

O que você quer dizer com " pool de memória "?

Um conjunto de memórias é um bloco de memória pré-alocado de tamanho fixo para manter pequenos blocos de memória por Buffers. O uso mantém os blocos de memória de tamanho pequeno firmemente juntos, evitando a fragmentação causada pelo gerenciamento separado (alocação e desalocação) de blocos de memória de tamanho pequeno.

Neste caso, os pools de memória são ArrayBuffers cujo tamanho é de 8 KiB por padrão, que é especificado em Buffer.poolSize. Quando é para fornecer um pedaço de memória de tamanho pequeno para a Buffer, ele verifica se o último pool de memória possui memória disponível suficiente para lidar com isso; nesse caso, cria um Bufferque "visualiza" o pedaço parcial fornecido do conjunto de memórias; caso contrário, cria um novo conjunto de memórias e assim por diante.

Você pode acessar o subjacente ArrayBufferde a Buffer. O Buffer's bufferpropriedade (ou seja, herdada Uint8Array) prende-lo. Um “pequeno” Buffer da bufferpropriedade é um ArrayBufferque representa todo o pool de memória. Portanto, neste caso, o ArrayBuffere Buffervaria em tamanho.

const zero_sized_buffer = Buffer.allocUnsafe(0);
const small_buffer = Buffer.from([0xC0, 0xFF, 0xEE]);
const big_buffer = Buffer.allocUnsafe(Buffer.poolSize >>> 1);

// A `Buffer`'s `length` property holds the size, in octets, of the view.
// An `ArrayBuffer`'s `byteLength` property holds the size, in octets, of its data.

console.info(zero_sized_buffer.length); /// 0; the view's size.
console.info(zero_sized_buffer.buffer.byteLength); /// 0; the memory..'s size.
console.info(Buffer.poolSize); /// 8192; a memory pool's size.

console.info(small_buffer.length); /// 3; the view's size.
console.info(small_buffer.buffer.byteLength); /// 8192; the memory pool's size.
console.info(Buffer.poolSize); /// 8192; a memory pool's size.

console.info(big_buffer.length); /// 4096; the view's size.
console.info(big_buffer.buffer.byteLength); /// 4096; the memory's size.
console.info(Buffer.poolSize); /// 8192; a memory pool's size.

3. Portanto, precisamos extrair a memória que " visualiza ".

Como o ArrayBuffertamanho é fixo, precisamos extraí-lo fazendo uma cópia da peça. Para fazer isso, usamos Buffer's byteOffsetpropriedade e lengthpropriedade , que são herdadas Uint8Array, e o ArrayBuffer.prototype.slicemétodo , que faz uma cópia de uma parte de um ArrayBuffer. O slice()método -ing aqui foi inspirado no @ZachB .

const test_buffer = Buffer.from(new ArrayBuffer(10));
const zero_sized_buffer = Buffer.allocUnsafe(0);
const small_buffer = Buffer.from([0xC0, 0xFF, 0xEE]);
const big_buffer = Buffer.allocUnsafe(Buffer.poolSize >>> 1);

function extract_arraybuffer(buf)
{
    // You may use the `byteLength` property instead of the `length` one.
    return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.length);
}

// A copy -
const test_arraybuffer = extract_arraybuffer(test_buffer); // of the memory.
const zero_sized_arraybuffer = extract_arraybuffer(zero_sized_buffer); // of the... void.
const small_arraybuffer = extract_arraybuffer(small_buffer); // of the part of the memory.
const big_arraybuffer = extract_arraybuffer(big_buffer); // of the memory.

console.info(test_arraybuffer.byteLength); // 10
console.info(zero_sized_arraybuffer.byteLength); // 0
console.info(small_arraybuffer.byteLength); // 3
console.info(big_arraybuffer.byteLength); // 4096

4. Melhoria de desempenho

Se você usar os resultados como somente leitura, ou se estiver modificando o Bufferconteúdo da entrada , poderá evitar cópias desnecessárias da memória.

const test_buffer = Buffer.from(new ArrayBuffer(10));
const zero_sized_buffer = Buffer.allocUnsafe(0);
const small_buffer = Buffer.from([0xC0, 0xFF, 0xEE]);
const big_buffer = Buffer.allocUnsafe(Buffer.poolSize >>> 1);

function obtain_arraybuffer(buf)
{
    if(buf.length === buf.buffer.byteLength)
    {
        return buf.buffer;
    } // else:
    // You may use the `byteLength` property instead of the `length` one.
    return buf.subarray(0, buf.length);
}

// Its underlying `ArrayBuffer`.
const test_arraybuffer = obtain_arraybuffer(test_buffer);
// Just a zero-sized `ArrayBuffer`.
const zero_sized_arraybuffer = obtain_arraybuffer(zero_sized_buffer);
// A copy of the part of the memory.
const small_arraybuffer = obtain_arraybuffer(small_buffer);
// Its underlying `ArrayBuffer`.
const big_arraybuffer = obtain_arraybuffer(big_buffer);

console.info(test_arraybuffer.byteLength); // 10
console.info(zero_sized_arraybuffer.byteLength); // 0
console.info(small_arraybuffer.byteLength); // 3
console.info(big_arraybuffer.byteLength); // 4096

Use o seguinte pacote de npm excelente: to-arraybuffer.

Ou, você pode implementá-lo você mesmo. Se seu buffer for chamado buf, faça o seguinte:

buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength)

Você pode pensar em um ArrayBuffercomo digitado Buffer.

Um, ArrayBufferportanto, sempre precisa de um tipo (a chamada "Visualização de buffer de matriz"). Normalmente, a exibição de buffer de matriz tem um tipo de Uint8Arrayou Uint16Array.

Há um bom artigo de Renato Mangini sobre a conversão entre um ArrayBuffer e um String .

Resumi as partes essenciais em um exemplo de código (para Node.js). Também mostra como converter entre o digitado ArrayBuffere o não digitado Buffer.

function stringToArrayBuffer(string) {
  const arrayBuffer = new ArrayBuffer(string.length);
  const arrayBufferView = new Uint8Array(arrayBuffer);
  for (let i = 0; i < string.length; i++) {
    arrayBufferView[i] = string.charCodeAt(i);
  }
  return arrayBuffer;
}

function arrayBufferToString(buffer) {
  return String.fromCharCode.apply(null, new Uint8Array(buffer));
}

const helloWorld = stringToArrayBuffer('Hello, World!'); // "ArrayBuffer" (Uint8Array)
const encodedString = new Buffer(helloWorld).toString('base64'); // "string"
const decodedBuffer = Buffer.from(encodedString, 'base64'); // "Buffer"
const decodedArrayBuffer = new Uint8Array(decodedBuffer).buffer; // "ArrayBuffer" (Uint8Array)

console.log(arrayBufferToString(decodedArrayBuffer)); // prints "Hello, World!"

Eu tentei o acima para um Float64Array e ele simplesmente não funcionou.

Acabei percebendo que realmente os dados precisavam ser lidos 'NA' visualização em partes corretas. Isso significa ler 8 bytes de cada vez no buffer de origem.

Enfim, é isso que eu acabei com ...

var buff = new Buffer("40100000000000004014000000000000", "hex");
var ab = new ArrayBuffer(buff.length);
var view = new Float64Array(ab);

var viewIndex = 0;
for (var bufferIndex=0;bufferIndex<buff.length;bufferIndex=bufferIndex+8)            {

    view[viewIndex] = buff.readDoubleLE(bufferIndex);
    viewIndex++;
}

Este proxy irá expor o buffer como qualquer um dos TypedArrays, sem nenhuma cópia. :

https://www.npmjs.com/package/node-buffer-as-typedarray

Funciona apenas no LE, mas pode ser facilmente portado para o BE. Além disso, nunca chegou a testar o quão eficiente isso é.

Agora há um pacote npm muito útil para isso: buffer https://github.com/feross/buffer

Ele tenta fornecer uma API 100% idêntica à API de buffer do nó e permite:

• converter matriz digitada em buffer: https://github.com/feross/buffer#convert-typed-array-to-buffer
• converter buffer em matriz digitada: https://github.com/feross/buffer#convert-buffer-to-typed-array

e mais alguns.

O NodeJS, em um ponto (acho que era v0.6.x), tinha suporte ao ArrayBuffer. Criei uma pequena biblioteca para codificação e decodificação base64 aqui , mas desde a atualização para a v0.7, os testes (no NodeJS) falham. Estou pensando em criar algo que normalize isso, mas até então, acho que o nativo do Node Bufferdeve ser usado.

Já atualizei meu nó para a versão 5.0.0 e trabalho com isso:

function toArrayBuffer(buffer){
    var array = [];
    var json = buffer.toJSON();
    var list = json.data

    for(var key in list){
        array.push(fixcode(list[key].toString(16)))
    }

    function fixcode(key){
        if(key.length==1){
            return '0'+key.toUpperCase()
        }else{
            return key.toUpperCase()
        }
    }

    return array
}

Eu o uso para verificar minha imagem de disco vhd.