Comment puis-je convertir un tampon binaire NodeJS en un ArrayBuffer JavaScript?

Les instances de Buffersont également des instances deUint8Array dans node.js 4.x et supérieur. Ainsi, la solution la plus efficace consiste à accéder buf.bufferdirectement à la propriété, selon https://stackoverflow.com/a/31394257/1375574 . Le constructeur Buffer prend également un argument ArrayBufferView si vous devez aller dans l'autre direction.

Notez que cela ne créera pas de copie, ce qui signifie que les écritures dans n'importe quel ArrayBufferView écriront dans l'instance Buffer d'origine.

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

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

Aucune dépendance, plus rapide, Node.js 4.x et versions ultérieures

Buffers sont des Uint8Arrays, il vous suffit donc de découper (copier) sa région du support 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);

Les slicetrucs et offset sont nécessaires car les petits Buffers (moins de 4 Ko par défaut, la moitié de la taille du pool ) peuvent être des vues sur un partage ArrayBuffer. Sans découpage, vous pouvez vous retrouver avec un ArrayBuffercontenant des données d'un autre Buffer. Voir l' explication dans la documentation .

Si vous en avez finalement besoin TypedArray, vous pouvez en créer un sans copier les données:

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

Aucune dépendance, vitesse modérée, toute version de Node.js

Utilisez la réponse de Martin Thomson , qui s'exécute dans le temps O (n) . (Voir aussi mes réponses aux commentaires sur sa réponse sur les non-optimisations. L'utilisation d'un DataView est lente. Même si vous devez inverser des octets, il existe des moyens plus rapides de le faire.)

Dépendance, rapide, Node.js ≤ 0,12 ou iojs 3.x

Vous pouvez utiliser https://www.npmjs.com/package/memcpy pour aller dans les deux sens (Buffer vers ArrayBuffer et retour). C'est plus rapide que les autres réponses publiées ici et c'est une bibliothèque bien écrite. Les nœuds 0.12 à iojs 3.x nécessitent le fork de ngossen (voir ceci ).

"From ArrayBuffer to Buffer" pourrait être fait de cette façon:

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

Une façon plus rapide de l'écrire

var arrayBuffer = new Uint8Array(nodeBuffer).buffer;

Cependant, cela semble fonctionner environ 4 fois plus lentement que la fonction toArrayBuffer suggérée sur un tampon avec 1024 éléments.

1. A Bufferest juste une vue pour regarder dans un fichier ArrayBuffer.

A Buffer, en fait, est a FastBuffer, qui extends(hérite de) Uint8Array, qui est une vue d' unité d'octet («accesseur partiel») de la mémoire réelle, 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. La taille d'un ArrayBufferet la taille de sa vue peuvent varier.

Raison n ° 1: Buffer.from(arrayBuffer[, byteOffset[, length]]).

Avec Buffer.from(arrayBuffer[, byteOffset[, length]]), vous pouvez créer un Bufferavec en spécifiant son sous ArrayBuffer- jacent ainsi que la position et la taille de la vue.

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.

Raison n ° 2: FastBufferl'allocation de mémoire de.

Il alloue la mémoire de deux manières différentes en fonction de la taille.

• Si la taille est inférieure à la moitié de la taille d'un pool de mémoire et n'est pas 0 («petit») : il utilise un pool de mémoire pour préparer la mémoire requise.
• Sinon : il crée un dédié ArrayBufferqui correspond exactement à la mémoire requise.

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

Qu'entendez-vous par « pool de mémoire »?

Un pool de mémoire est un bloc de mémoire pré-alloué de taille fixe pour conserver des blocs de mémoire de petite taille pendant Buffers. Son utilisation permet de maintenir les blocs de mémoire de petite taille étroitement ensemble, évitant ainsi la fragmentation causée par la gestion séparée (allocation et désallocation) des blocs de mémoire de petite taille.

Dans ce cas, les pools de mémoire sont des ArrayBuffers dont la taille par défaut est de 8 Kio, ce qui est spécifié dans Buffer.poolSize. Lorsqu'il doit fournir un bloc de mémoire de petite taille pour a Buffer, il vérifie si le dernier pool de mémoire dispose de suffisamment de mémoire disponible pour gérer cela; si c'est le cas, il crée un Bufferqui «visualise» le bloc partiel donné du pool de mémoire, sinon, il crée un nouveau pool de mémoire et ainsi de suite.

Vous pouvez accéder au sous-jacent ArrayBufferd'un Buffer. La propriétéBuffer s (c'est-à-dire héritée de ) la détient. Un « petit » de propriété est un qui représente l'ensemble du pool de mémoire. Donc, dans ce cas, le et le varient en taille.bufferUint8Array 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. Nous devons donc extraire la mémoire qu'il « visualise ».

An ArrayBufferest de taille fixe, nous devons donc l'extraire en faisant une copie de la pièce. Pour ce faire, nous utilisons Bufferla byteOffsetpropriété et la lengthpropriété de , qui sont héritées de Uint8Array, et la ArrayBuffer.prototype.sliceméthode , qui fait une copie d'une partie d'un fichier ArrayBuffer. La slice()méthode -ing ici a été inspirée par @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. Amélioration des performances

Si vous utilisez les résultats en lecture seule ou siBuffer vous pouvez modifier le contenu des entrées , vous pouvez éviter une copie inutile de la mémoire.

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

Utilisez le paquet excellent NPM suivant: to-arraybuffer.

Ou vous pouvez le mettre en œuvre vous-même. Si votre tampon est appelé buf, procédez comme suit:

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

Vous pouvez considérer un ArrayBuffercomme un fichier tapé Buffer.

An a ArrayBufferdonc toujours besoin d'un type (appelé "Array Buffer View"). En règle générale, la vue de la mémoire tampon du tableau a un type de Uint8Arrayou Uint16Array.

Il y a un bon article de Renato Mangini sur la conversion entre un ArrayBuffer et une String .

J'ai résumé les parties essentielles dans un exemple de code (pour Node.js). Il montre également comment convertir entre le typé ArrayBufferet le non typé 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!"

J'ai essayé ce qui précède pour un Float64Array et cela ne fonctionnait tout simplement pas.

J'ai fini par réaliser que vraiment les données devaient être lues «DANS» la vue en morceaux corrects. Cela signifie lire 8 octets à la fois à partir du tampon source.

Bref, c'est ce avec quoi j'ai fini ...

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

Ce proxy exposera le tampon comme l'un des TypedArrays, sans aucune copie. :

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

Cela ne fonctionne que sur LE, mais peut être facilement porté vers BE. De plus, je n'ai jamais eu à tester l'efficacité de cette méthode.

Il existe maintenant un package npm très utile pour cela: buffer https://github.com/feross/buffer

Il tente de fournir une API identique à 100% à l'API Buffer du nœud et autorise:

• convertir le tableau typé en tampon: https://github.com/feross/buffer#convert-typed-array-to-buffer
• convertir le tampon en tableau typé: https://github.com/feross/buffer#convert-buffer-to-typed-array

et quelques autres.

NodeJS, à un moment donné (je pense que c'était v0.6.x) avait le support ArrayBuffer. J'ai créé une petite bibliothèque pour l'encodage et le décodage base64 ici , mais depuis la mise à jour vers la v0.7, les tests (sur NodeJS) échouent. Je pense créer quelque chose qui normalise cela, mais jusque-là, je suppose que le natif de Node Bufferdevrait être utilisé.

J'ai déjà mis à jour mon nœud vers la version 5.0.0 et je travaille avec ceci:

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
}

Je l'utilise pour vérifier mon image disque vhd.