Wie kann ich einen NodeJS-Binärpuffer in einen JavaScript-ArrayBuffer konvertieren?

Instanzen von Buffersind auch Instanzen vonUint8Array in node.js 4.x und höher. Die effizienteste Lösung ist daher der buf.bufferdirekte Zugriff auf die Eigenschaft gemäß https://stackoverflow.com/a/31394257/1375574 . Der Buffer-Konstruktor verwendet auch ein ArrayBufferView-Argument, wenn Sie in die andere Richtung gehen müssen.

Beachten Sie, dass dadurch keine Kopie erstellt wird. Dies bedeutet, dass beim Schreiben in eine ArrayBufferView in die ursprüngliche Buffer-Instanz geschrieben wird.

Vom Puffer zum 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;
}

Von ArrayBuffer zu 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;
}

Keine Abhängigkeiten, am schnellsten, Node.js 4.x und höher

Buffers sind Uint8Arrays, Sie müssen also nur den Bereich des Hintergrunds in Scheiben schneiden (kopieren) 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);

Das sliceund Offset-Material ist erforderlich, da kleine Buffers (standardmäßig weniger als 4 kB, die Hälfte der Poolgröße ) Ansichten auf einer gemeinsam genutzten Datei sein können ArrayBuffer. Ohne Slicing können Sie ArrayBufferDaten von einem anderen erhalten Buffer. Siehe Erklärung in den Dokumenten .

Wenn Sie letztendlich eine benötigen TypedArray, können Sie eine erstellen, ohne die Daten zu kopieren:

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

Keine Abhängigkeiten, mäßige Geschwindigkeit, jede Version von Node.js.

Verwenden Sie die Antwort von Martin Thomson , die in O (n) Zeit ausgeführt wird. (Siehe auch meine Antworten auf Kommentare zu seiner Antwort zu Nichtoptimierungen. Die Verwendung einer DataView ist langsam. Selbst wenn Sie Bytes umdrehen müssen, gibt es schnellere Möglichkeiten.)

Abhängigkeit, schnell, Node.js ≤ 0,12 oder iojs 3.x.

Sie können https://www.npmjs.com/package/memcpy verwenden , um in beide Richtungen zu gelangen (Buffer to ArrayBuffer und zurück). Es ist schneller als die anderen hier veröffentlichten Antworten und eine gut geschriebene Bibliothek. Knoten 0.12 bis iojs 3.x erfordern die Gabel von ngossen (siehe hier ).

"Von ArrayBuffer zu Puffer" könnte folgendermaßen erfolgen:

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

Ein schnellerer Weg, um es zu schreiben

var arrayBuffer = new Uint8Array(nodeBuffer).buffer;

Dies scheint jedoch ungefähr viermal langsamer zu laufen als die vorgeschlagene Funktion toArrayBuffer für einen Puffer mit 1024 Elementen.

1. A. Buffer ist nur eine Ansicht zum Betrachten eines ArrayBuffer.

A Bufferist in der Tat ein FastBuffer, das extends(erbt von) Uint8Array, was eine Oktetteinheit ist Ansicht ( „partial Accessor“) des Ist - Speicher, eineArrayBuffer .

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

Buffer.prototype = FastBuffer.prototype;

2. Die Größe eines ArrayBufferund die Größe seiner Ansicht können variieren.

Grund Nr. 1: Buffer.from(arrayBuffer[, byteOffset[, length]]) .

Mit Buffer.from(arrayBuffer[, byteOffset[, length]])können Sie ein Buffermit Angabe des Basiswerts erstellenArrayBuffer sowie der Position und Größe der Ansicht .

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.

Grund Nr. 2: FastBuffer Speicherzuordnung.

Der Speicher wird je nach Größe auf zwei verschiedene Arten zugewiesen.

• Wenn die Größe weniger als die Hälfte der Größe eines Speicherpools beträgt und nicht 0 („klein“) ist, wird a verwendet Speicherpool verwendet , um den erforderlichen Speicher vorzubereiten.
• Sonst : es schafft eine dedizierteArrayBuffer Speicher , der genau zum erforderlichen Speicher passt.

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

Was meinst du mit einem „ Speicherpool "?

Ein Speicherpool ist ein vorab zugewiesener Speicherblock mit fester Größe , um kleine Speicherblöcke für Buffers aufzubewahren . Durch die Verwendung werden die kleinen Speicherblöcke eng zusammengehalten, wodurch dies verhindert wird Fragmentierung die durch die separate Verwaltung (Zuweisung und Freigabe) kleiner Speicherblöcke verursacht wird.

In diesem Fall handelt es sich bei den Speicherpools um ArrayBuffers, deren Größe standardmäßig 8 KB beträgt Buffer.poolSize. Dies ist in angegeben . Wenn ein kleiner Speicherblock für a Bufferbereitgestellt werden soll, wird geprüft, ob der letzte Speicherpool über genügend verfügbaren Speicher verfügt, um dies zu handhaben. In diesem Fall wird ein Element erstellt Buffer, das den angegebenen Teil des Speicherpools "anzeigt". Andernfalls wird ein neuer Speicherpool erstellt und so weiter.

Sie können auf den Basiswert ArrayBuffervon a zugreifen Buffer. Die Buffer‚s - bufferEigenschaft (das heißt, geerbt von Uint8Array) hält. Eine „kleine“ Buffer ‚s - bufferEigenschaft ist eine ArrayBuffer, die den gesamten Speicher - Pool darstellt. In diesem Fall variiert das ArrayBufferund das Bufferin der Größe.

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. Wir müssen also den Speicher extrahieren, den es " ansieht ".

An ArrayBufferhat eine feste Größe, daher müssen wir es herausziehen, indem wir eine Kopie des Teils erstellen. Dazu verwenden wir Buffer‚s byteOffsetEigentum und lengthImmobilien , die von vererbt werden Uint8Array, und das ArrayBuffer.prototype.sliceVerfahren , das eine Kopie eines Teils eines macht ArrayBuffer. Die hier beschriebene slice()-ing-Methode wurde von @ZachB inspiriert .

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. Leistungsverbesserung

Wenn Sie die Ergebnisse schreibgeschützt verwenden oder den BufferInhalt der Eingabe ändern möchten , können Sie unnötiges Kopieren des Speichers vermeiden.

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

Verwenden Sie das folgende ausgezeichnete npm-Paket : to-arraybuffer.

Oder Sie können es selbst implementieren. Wenn Ihr Puffer aufgerufen wird buf, gehen Sie folgendermaßen vor:

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

Sie können sich eine ArrayBufferals getippt vorstellen Buffer.

Ein benötigt ArrayBufferdaher immer einen Typ (die sogenannte "Array Buffer View"). In der Regel hat die Array-Pufferansicht den Typ Uint8Arrayoder Uint16Array.

Es gibt einen guten Artikel von Renato Mangini über die Konvertierung zwischen einem ArrayBuffer und einem String .

Ich habe die wesentlichen Teile in einem Codebeispiel (für Node.js) zusammengefasst. Es wird auch gezeigt, wie zwischen typisiert ArrayBufferund untypisiert konvertiert wird 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!"

Ich habe das oben für ein Float64Array ausprobiert und es hat einfach nicht funktioniert.

Am Ende wurde mir klar, dass die Daten wirklich in korrekten Blöcken in die Ansicht gelesen werden mussten. Dies bedeutet, dass jeweils 8 Bytes aus dem Quellpuffer gelesen werden.

Jedenfalls ist es das, was ich am Ende hatte ...

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

Dieser Proxy macht den Puffer als eines der TypedArrays ohne Kopie verfügbar. ::

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

Es funktioniert nur mit LE, kann aber problemlos auf BE portiert werden. Außerdem musste ich nie testen, wie effizient dies ist.

Jetzt gibt es dafür ein sehr nützliches npm-Paket: buffer https://github.com/feross/buffer

Es wird versucht, eine API bereitzustellen, die zu 100% mit der Puffer-API des Knotens identisch ist, und Folgendes zuzulassen:

• Typisiertes Array in Puffer konvertieren: https://github.com/feross/buffer#convert-typed-array-to-buffer
• Konvertieren Sie den Puffer in ein typisiertes Array: https://github.com/feross/buffer#convert-buffer-to-typed-array

und einige mehr.

NodeJS hatte zu einem bestimmten Zeitpunkt (ich glaube es war v0.6.x) ArrayBuffer-Unterstützung. Ich habe eine kleine Bibliothek für Base64 - Codierung und Decodierung hier , sondern auf v0.7 seit der Aktualisierung die Tests (auf NodeJS) scheitern. Ich denke darüber nach, etwas zu schaffen, das dies normalisiert, aber bis dahin Buffersollte wohl Node's Native verwendet werden.

Ich habe meinen Knoten bereits auf Version 5.0.0 aktualisiert und arbeite damit:

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
}

Ich benutze es, um mein VHD-Image zu überprüfen.