Как я могу преобразовать двоичный буфер NodeJS в JavaScript ArrayBuffer?

Экземпляры Bufferтакже являются экземплярамиUint8Array в node.js 4.x и выше. Таким образом, наиболее эффективным решением является buf.bufferпрямой доступ к свойству в соответствии с https://stackoverflow.com/a/31394257/1375574 . Конструктор Buffer также принимает аргумент ArrayBufferView, если вам нужно пойти в другом направлении.

Обратите внимание, что это не создаст копию, а это означает, что запись в любой ArrayBufferView будет записывать в исходный экземпляр Buffer.

Из буфера в 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;
}

От ArrayBuffer к 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;
}

Без зависимостей, самый быстрый, Node.js 4.x и новее

Buffers есть Uint8Arrays, поэтому вам просто нужно разрезать (скопировать) его область подложки 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);

Материал sliceи смещение требуется, потому что маленькие Buffers (по умолчанию менее 4 КБ, половина размера пула ) могут быть представлениями на общем ресурсе ArrayBuffer. Без нарезки вы можете получить ArrayBufferданные из другого Buffer. См. Объяснение в документации .

Если вам в конечном итоге понадобится TypedArray, вы можете создать его, не копируя данные:

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

Никаких зависимостей, умеренная скорость, любая версия Node.js

Используйте ответ Мартина Томсона , который выполняется за время O (n) . (См. Также мои ответы на комментарии к его ответу о неоптимизации. Использование DataView происходит медленно. Даже если вам нужно перевернуть байты, есть более быстрые способы сделать это.)

Зависимость, быстро, Node.js ≤ 0,12 или iojs 3.x

Вы можете использовать https://www.npmjs.com/package/memcpy, чтобы двигаться в любом направлении (от буфера до ArrayBuffer и обратно). Это быстрее, чем другие ответы, опубликованные здесь, и это хорошо написанная библиотека. Узлы от 0.12 до iojs 3.x требуют форка ngossen (см. Это ).

«От ArrayBuffer до Buffer» можно сделать так:

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

Более быстрый способ написать это

var arrayBuffer = new Uint8Array(nodeBuffer).buffer;

Однако, похоже, что он работает примерно в 4 раза медленнее, чем предлагаемая функция toArrayBuffer в буфере с 1024 элементами.

1. А Buffer- это просто вид для изучения ArrayBuffer.

Buffer, По сути, представляет собой FastBuffer, который extends(наследует от) Uint8Array, который представляет собой октет-блок вид ( «частичный аксессор») от фактической памяти, с 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. Размер ArrayBufferи размер его вида могут различаться.

Причина № 1: Buffer.from(arrayBuffer[, byteOffset[, length]]).

С помощью Buffer.from(arrayBuffer[, byteOffset[, length]]), вы можете создать Bufferс указанием его основы ArrayBufferи позиции и размера представления.

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.

Причина № 2: FastBufferвыделение памяти.

Он распределяет память двумя различными способами в зависимости от размера.

• Если размер меньше половины размера пула памяти и не равен 0 («маленький») : он использует пул памяти для подготовки необходимой памяти.
• Иначе : он создает выделенный, ArrayBufferкоторый точно соответствует требуемой памяти.

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));
}

Что вы подразумеваете под « пул памяти ?»

Пул памяти является фиксированным размером предварительно выделен блоком памяти для хранения кусков памяти малого размера для Bufferс. Его использование обеспечивает плотное соединение небольших блоков памяти, что предотвращает фрагментацию. вызванную раздельным управлением (выделением и освобождением) блоков памяти малого размера.

В этом случае используются пулы памяти ArrayBufferс размером по умолчанию 8 КиБ, который указан в Buffer.poolSize. Когда он должен предоставить блок памяти небольшого размера для a Buffer, он проверяет, имеет ли последний пул памяти достаточно доступной памяти для обработки этого; если это так, он создает объект, Bufferкоторый «просматривает» данный частичный фрагмент пула памяти, в противном случае он создает новый пул памяти и так далее.

Вы можете получить доступ к основному ArrayBufferиз Buffer. В Buffer«S bufferсвойство (то есть, унаследованное от Uint8Array) удерживает его. «Небольшой» «s свойство является , который представляет весь пул памяти. Так что в этом случае размер и меняется. BufferbufferArrayBufferArrayBufferBuffer

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. Поэтому нам нужно извлечь память, которую он « просматривает ».

ArrayBufferФиксируется в размерах, так что мы должны извлечь его, сделав копию части. Для этого мы используем Buffer«ю.ш.byteOffset имущество и lengthимущество , которые наследуются от Uint8Arrayи на ArrayBuffer.prototype.sliceметод , который делает копию части ArrayBuffer. Метод slice()-ing здесь был вдохновлен @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. Улучшение производительности

Если вы хотите использовать результаты только для чтения или если вы можете изменить Bufferсодержимое входных данных , вы можете избежать ненужного копирования в память.

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

Используйте следующий превосходный пакет NPM: to-arraybuffer.

Или вы можете реализовать это самостоятельно. Если ваш буфер вызывается buf, сделайте это:

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

Вы можете думать ArrayBufferкак о набранных Buffer.

ArrayBufferПоэтому всегда нужен тип (так называемый «Array Buffer View»). Как правило, Array Buffer View имеет тип Uint8Arrayили Uint16Array.

Есть хорошая статья от Ренато Манджини о преобразовании между ArrayBuffer и String .

Я суммировал основные части в примере кода (для Node.js). Также показано, как конвертировать между типизированным ArrayBufferи нетипизированным 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!"

Я попытался выше для Float64Array, и он просто не работал.

Я понял, что на самом деле данные должны быть прочитаны «INTO» в виде правильных кусков. Это означает чтение 8 байтов за раз из исходного буфера.

Во всяком случае, это то, что я закончил ...

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++;
}

Этот прокси будет представлять буфер как любой из TypedArrays, без какой-либо копии. :

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

Он работает только на LE, но может быть легко перенесен на BE. Кроме того, никогда не проверял, насколько это эффективно.

Теперь для этого есть очень полезный пакет npm: buffer https://github.com/feross/buffer

Он пытается предоставить API, который на 100% идентичен Buffer API узла и позволяет:

• преобразовать типизированный массив в буфер: https://github.com/feross/buffer#convert-typed-array-to-buffer
• преобразовать буфер в типизированный массив: https://github.com/feross/buffer#convert-buffer-to-typed-array

и еще немного.

NodeJS, в какой-то момент (я думаю, это был v0.6.x) была поддержка ArrayBuffer. Я создал небольшую библиотеку для base64 кодирования и декодирования здесь , но так как обновление до v0.7, тесты (на NodeJS) терпят неудачу. Я думаю о создании чего-то, что нормализует это, но до тех пор, я полагаю, Bufferдолжен использоваться нативный нод.

Я уже обновил свой узел до версии 5.0.0, и я работаю с этим:

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
}

Я использую его для проверки образа моего VHD-диска.