Bagaimana saya bisa mengubah buffer biner NodeJS menjadi JavaScript ArrayBuffer?

Instance Bufferjuga instanceUint8Array dalam node.js 4.x dan lebih tinggi. Dengan demikian, solusi paling efisien adalah mengakses buf.bufferproperti secara langsung, seperti https://stackoverflow.com/a/31394257/1375574 . Konstruktor Buffer juga mengambil argumen ArrayBufferView jika Anda perlu pergi ke arah lain.

Perhatikan bahwa ini tidak akan membuat salinan, yang berarti bahwa menulis ke ArrayBufferView apa pun akan menulis hingga contoh Buffer asli.

Dari Buffer ke 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;
}

Dari ArrayBuffer ke 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;
}

Tidak ada dependensi, tercepat, Node.js 4.x dan yang lebih baru

Buffers adalah Uint8Arrays, jadi Anda hanya perlu mengiris (menyalin) wilayah dukungannya 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);

The slicehal-hal dan offset diperlukan karena kecil Buffers (kurang dari 4 kB secara default, setengah ukuran kolam ) dapat dilihat pada bersama ArrayBuffer. Tanpa mengiris, Anda bisa berakhir dengan ArrayBufferberisi data dari yang lain Buffer. Lihat penjelasan dalam dokumen .

Jika pada akhirnya Anda membutuhkan TypedArray, Anda dapat membuatnya tanpa menyalin data:

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

Tidak ada dependensi, kecepatan sedang, versi Node.js apa pun

Gunakan jawaban Martin Thomson , yang berjalan dalam O (n) waktu. (Lihat juga balasan saya untuk komentar pada jawabannya tentang non-optimisasi. Menggunakan DataView lambat. Bahkan jika Anda perlu membalik byte, ada cara yang lebih cepat untuk melakukannya.)

Ketergantungan, cepat, Node.js ≤ 0,12 atau iojs 3.x

Anda dapat menggunakan https://www.npmjs.com/package/memcpy untuk menuju salah satu arah (Buffer ke ArrayBuffer dan kembali). Ini lebih cepat daripada jawaban lain yang diposting di sini dan merupakan perpustakaan yang ditulis dengan baik. Simpul 0,12 hingga iojs 3.x memerlukan garpu ngossen (lihat ini ).

"Dari ArrayBuffer ke Buffer" dapat dilakukan dengan cara ini:

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

Cara yang lebih cepat untuk menulisnya

var arrayBuffer = new Uint8Array(nodeBuffer).buffer;

Namun, ini tampaknya berjalan kira-kira 4 kali lebih lambat daripada fungsi toArrayBuffer yang disarankan pada buffer dengan 1024 elemen.

1. A Bufferhanyalah tampilan untuk melihat ke dalam ArrayBuffer.

A Buffer, pada kenyataannya, adalah a FastBuffer, yang extends(mewarisi dari) Uint8Array, yang merupakan tampilan satuan oktet ("pengakses parsial") dari memori aktual, 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. Ukuran ArrayBufferdan ukuran tampilan dapat bervariasi.

Alasan # 1: Buffer.from(arrayBuffer[, byteOffset[, length]]).

Dengan Buffer.from(arrayBuffer[, byteOffset[, length]]), Anda dapat membuat Bufferdengan menentukan dasarnya ArrayBufferdan posisi serta ukuran tampilan.

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.

Alasan # 2: FastBufferalokasi memori.

Ini mengalokasikan memori dalam dua cara berbeda tergantung pada ukurannya.

• Jika ukurannya kurang dari setengah ukuran kolam memori dan bukan 0 ("kecil") : itu menggunakan kolam memori untuk menyiapkan memori yang diperlukan.
• Lain : itu menciptakan dedicated ArrayBufferyang persis sesuai dengan memori yang diperlukan.

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

Apa yang Anda maksud dengan " kumpulan memori ?"

Kumpulan memori adalah blok memori pra-alokasi ukuran tetap untuk menjaga potongan memori berukuran kecil untuk Buffers. Menggunakannya membuat potongan memori ukuran kecil tetap rapat, sehingga mencegah fragmentasi yang disebabkan oleh manajemen yang terpisah (alokasi dan deallokasi) dari potongan memori ukuran kecil.

Dalam kasus ini, kumpulan memori adalah ArrayBuffers yang ukurannya 8 KiB secara default, yang ditentukan dalam Buffer.poolSize. Ketika akan menyediakan potongan memori ukuran kecil untuk a Buffer, itu memeriksa apakah kumpulan memori terakhir memiliki cukup memori yang tersedia untuk menangani ini; jika demikian, itu menciptakan Bufferyang “dilihat” potongan parsial diberikan dari kolam memori, jika tidak, itu menciptakan kolam memori baru dan sebagainya.

Anda dapat mengakses dasar ArrayBufferdari a Buffer. The Buffer's bufferproperti (yaitu, diwarisi dari Uint8Array) memegang itu. Sebuah “kecil” Buffer 's bufferproperti merupakan ArrayBufferyang mewakili seluruh kolam memori. Jadi dalam hal ini, ArrayBufferdan Bufferukurannya bervariasi.

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. Jadi kita perlu mengekstrak memori itu " dilihat ."

Sebuah ArrayBufferadalah tetap dalam ukuran, sehingga kita perlu untuk mengambil keluar dengan membuat salinan bagian. Untuk melakukan hal ini, kita menggunakan Buffer's byteOffsetproperti dan lengthproperti , yang diwarisi dari Uint8Array, dan yang ArrayBuffer.prototype.slicemetode , yang membuat salinan bagian dari ArrayBuffer. The slice()Metode -ing disini terinspirasi oleh @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. Peningkatan kinerja

Jika Anda menggunakan hasil sebagai hanya-baca, atau apa-apa untuk mengubah masukan Buffers'isi , Anda dapat menghindari yang tidak perlu menyalin memori.

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

Menggunakan paket NPM sangat baik sebagai berikut: to-arraybuffer.

Atau, Anda bisa menerapkannya sendiri. Jika buffer Anda dipanggil buf, lakukan ini:

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

Anda dapat menganggap ArrayBuffersebagai diketik Buffer.

Sebuah ArrayBufferkarena itu selalu membutuhkan jenis (yang disebut "Array Buffer View"). Biasanya, Array Buffer View memiliki tipe Uint8Arrayatau Uint16Array.

Ada artikel bagus dari Renato Mangini tentang konversi antara ArrayBuffer dan String .

Saya telah merangkum bagian-bagian penting dalam contoh kode (untuk Node.js). Ini juga menunjukkan bagaimana mengkonversi antara yang diketik ArrayBufferdan yang tidak diketik 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!"

Saya mencoba di atas untuk Float64Array dan itu tidak berhasil.

Saya akhirnya menyadari bahwa benar-benar data yang perlu dibaca 'KEPADA' tampilan dalam potongan yang benar. Ini berarti membaca 8 byte sekaligus dari Buffer sumber.

Pokoknya inilah yang akhirnya saya dapatkan dengan ...

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

Proxy ini akan mengekspos buffer sebagai salah satu dari TypedArrays, tanpa salinan apa pun. :

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

Ini hanya bekerja pada LE, tetapi dapat dengan mudah dipindahkan ke BE. Juga, tidak pernah benar-benar menguji seberapa efisien ini.

Sekarang ada paket npm yang sangat berguna untuk ini: buffer https://github.com/feross/buffer

Ia mencoba menyediakan API yang 100% identik dengan API Penyangga simpul dan memungkinkan:

• konversi array yang diketik ke buffer: https://github.com/feross/buffer#convert-typed-array-to-buffer
• konversi buffer ke array yang diketik: https://github.com/feross/buffer#convert-buffer-to-typed-array

dan beberapa lagi.

NodeJS, pada satu titik (saya pikir itu v0.6.x) mendapat dukungan ArrayBuffer. Saya membuat perpustakaan kecil untuk encoding dan decoding base64 di sini , tetapi sejak memperbarui ke v0.7, tes (pada NodeJS) gagal. Saya sedang berpikir untuk menciptakan sesuatu yang menormalkan ini, tetapi sampai saat itu, saya kira asli Node Bufferharus digunakan.

Saya sudah memperbarui simpul saya ke Versi 5.0.0 Dan saya bekerja dengan ini:

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
}

Saya menggunakannya untuk memeriksa image disk VHD saya.