nodejs conversion from buffer data to byte array

Question

I want to convert buffer data to byte array. Here's what I've tried

import * as fs from 'fs';
[...]
event:(data) => {
   fs.readFile(data, function(err, data) {
      var arrByte= new Uint8Array(data)
      var binaryData= new Blob([arrByte])
      console.log(binaryData)
   }
 }

I'm yet to have this work hence my post. I'd very much like to know what I'm doing that's not right.

Solution 1

The Buffer docs are very enlightening:

Prior to the introduction of TypedArray, the JavaScript language had no mechanism for reading or manipulating streams of binary data. The Buffer class was introduced as part of the Node.js API to enable interaction with octet streams in TCP streams, file system operations, and other contexts.

With TypedArray now available, the Buffer class implements the Uint8Array API in a manner that is more optimized and suitable for Node.js.

…

Buffer instances are also Uint8Array instances. However, there are subtle incompatibilities with TypedArray. For example, while ArrayBuffer#slice() creates a copy of the slice, the implementation of Buffer#slice() creates a view over the existing Buffer without copying, making Buffer#slice() far more efficient.

It is also possible to create new TypedArray instances from a Buffer with the following caveats:

1. The Buffer object's memory is copied to the TypedArray, not shared.

2. The Buffer object's memory is interpreted as an array of distinct elements, and not as a byte array of the target type. That is, new Uint32Array(Buffer.from([1, 2, 3, 4])) creates a 4-element Uint32Array with elements [1, 2, 3, 4], not a Uint32Array with a single element [0x1020304] or [0x4030201].

They go on to mention TypedArray.from, which in node accepts Buffers, so the 'correct' way is:

var arrByte = Uint8Array.from(data)

...however, this shouldn't be necessary at all since a Buffer is a Uint8Array and new UintArray(someBuffer) does work just fine.

There's also no context in your question, but Blob doesn't exist in node, and you shouldn't need it anyway, since Buffer already gives you raw access to binary data and the other fs methods let you read and write files.

Solution 2

  import * as fs from 'fs';
  [...]
  event:(data) => {
    fs.readFile(data, function(err, data) {
      var arrByte= new Uint8Array.from(Buffer.from(data))
      var binaryData= new Blob([arrByte])
      if (err) throw err;
      console.log(binaryData)
    }
 }

Comments

[Cerberus]

What's the problem with this code?

[lilKing]

Thanks for the post. However, logging arrByte gives this output Uint8Array [ ]

[josh3736]

And what is your buffer (data)? What is err? I bet you're getting an error and ignoring it. Never skip error checking -- always check err in node callbacks.

[lilKing]

this is the buffer data from fingerprint renderer process <Buffer ff d8 ff e0 00 10 4a 46 49 46 00 01 01 01 01 f4 01 f4 00 00 ff db 00 43 00 08 ...> which I want to convert to byte[] and I've also checked if (err) throw err... Guess there's no err

[lilKing]

i was able to get Uint8Array(55797) [255, 216, 255, 224, 0, 16, 74, 70, 73, 70, 0, 1, 1, 1, 1, 244, ...] when i set arrByte to Uint8Array.from(Buffer.from(data)) Thanks a lot

[MidhunKrishna]

@lilKing Hi, can you pls share the code here, because iam also having the same issue converting buffer data to byte array.

[lilKing]

@MidhunKrishna I'll post it shortly. Hope it helps

[Vikas Satpute]

What is the type of "data" variable?

[Andy]

@VikasSatpute in the outer context (i.e. as the first parameter to fs.readFile) it's the file name; in the inner context it's the data read from the file. In my tests, the inner data is already of type Buffer so you don't need to call Buffer.from(data) at all.