ฉันจะแปลงบัฟเฟอร์ไบนารี NodeJS เป็น JavaScript ArrayBuffer ได้อย่างไร

อินสแตนซ์ของBufferยังเป็นอินสแตนซ์Uint8Arrayใน node.js 4.x และสูงกว่า ดังนั้นวิธีการแก้ปัญหาที่มีประสิทธิภาพมากที่สุดคือการเข้าถึงbuf.bufferคุณสมบัติตรงตามhttps://stackoverflow.com/a/31394257/1375574 ตัวสร้างบัฟเฟอร์ยังใช้อาร์กิวเมนต์ 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;

อย่างไรก็ตามดูเหมือนว่าจะทำงานช้ากว่าฟังก์ชัน toArrayBuffer ที่แนะนำไว้ประมาณ 4 เท่าบนบัฟเฟอร์ที่มี 1024 องค์ประกอบ

1. A Bufferเป็นเพียงมุมมองสำหรับการค้นหาไฟล์ArrayBufferไฟล์.

A Bufferในความเป็นจริงคือ a FastBufferซึ่งextends(สืบทอดมาจาก) Uint8Arrayซึ่งเป็นมุมมองหน่วยออกเตต(“ ตัวเข้าถึงบางส่วน”) ของหน่วยความจำจริง a 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]])1:

ด้วย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));
}

คุณหมายถึงอะไรโดย " หน่วยความจำ "

สระว่ายน้ำของหน่วยความจำเป็นขนาดคงที่ก่อนจัดสรรบล็อกหน่วยความจำสำหรับการเก็บรักษาชิ้นหน่วยความจำขนาดเล็กสำหรับBuffers การใช้มันช่วยให้หน่วยความจำขนาดเล็กเข้าด้วยกันอย่างแน่นหนาดังนั้นจึงป้องกันการแยกส่วนที่เกิดจากการจัดการแยกต่างหาก (การจัดสรรและการจัดสรร) ของหน่วยความจำขนาดเล็ก

ในกรณีนี้พูลหน่วยความจำคือArrayBuffers ที่มีขนาด 8 KiB ตามค่าเริ่มต้นซึ่งระบุไว้ในBuffer.poolSize. เมื่อต้องการให้หน่วยความจำขนาดเล็กสำหรับ a Bufferจะตรวจสอบว่าพูลหน่วยความจำสุดท้ายมีหน่วยความจำเพียงพอที่จะจัดการสิ่งนี้หรือไม่ ถ้าเป็นเช่นนั้นมันจะสร้างBufferที่“มุมมอง”ที่ได้รับก้อนบางส่วนของสระว่ายน้ำของหน่วยความจำมิฉะนั้นมันจะสร้างสระว่ายน้ำหน่วยความจำใหม่และอื่น ๆ

คุณสามารถเข้าถึงพื้นฐานArrayBufferของไฟล์Buffer. Buffer's bufferคุณสมบัติ (นั่นคือสืบทอดมาจากUint8Array) ถือมัน “เล็ก”ของสถานที่ให้บริการเป็นที่หมายถึงสระว่ายน้ำของหน่วยความจำทั้งหมด ดังนั้นในกรณีนี้และแตกต่างกันไปในขนาด 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และวิธีการซึ่งทำให้สำเนาส่วนหนึ่งของการเป็น วิธีไอเอ็นจีในเอกสารฉบับนี้ได้รับแรงบันดาลใจจาก@ZachBArrayBuffer.prototype.sliceArrayBufferslice()

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มีประเภทUint8ArrayหรือUint16Array.

มีบทความที่ดีจาก Renato Mangini บนเป็นแปลงระหว่าง ArrayBuffer และสตริง

ฉันได้สรุปส่วนสำคัญในตัวอย่างโค้ด (สำหรับ Node.js) นอกจากนี้ยังแสดงให้เห็นถึงวิธีการแปลงระหว่างพิมพ์ArrayBufferและ Bufferuntyped

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 แล้วก็ไม่ได้ผล

ฉันพบว่าข้อมูลที่จำเป็นในการอ่าน 'เข้า' มุมมองในส่วนที่ถูกต้องจริงๆ ซึ่งหมายถึงการอ่านครั้งละ 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ควรใช้Node ของ Node

ฉันได้อัปเดตโหนดของฉันเป็นเวอร์ชัน 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 ของฉัน