You are missing the padding in the hex conversion. You'll want to use

function toHexString(byteArray) {
  return Array.from(byteArray, function(byte) {
    return ('0' + (byte & 0xFF).toString(16)).slice(-2);
  }).join('')
}

so that each byte transforms to exactly two hex digits. Your expected output would be 04812d7e3a9829e5d51bdd64ceb35df060699bc1309731bd6e6f1a5443a7f9ce0af4382fcfd6f5f8a08bb2619709c2d49fb771601770f2c267985af2754e1f8cf9

Convert a hex string to a byte array and vice versa

note: implementation from crypto-js, though now out of date and slightly altered

// Convert a hex string to a byte array
function hexToBytes(hex) {
    let bytes = [];
    for (let c = 0; c < hex.length; c += 2)
        bytes.push(parseInt(hex.substr(c, 2), 16));
    return bytes;
}

// Convert a byte array to a hex string
function bytesToHex(bytes) {
    let hex = [];
    for (let i = 0; i < bytes.length; i++) {
        let current = bytes[i] < 0 ? bytes[i] + 256 : bytes[i];
        hex.push((current >>> 4).toString(16));
        hex.push((current & 0xF).toString(16));
    }
    return hex.join("");
}

A single liner :

   '[86400:?]'.split ('').map (function (c) { return c.charCodeAt (0); })

returns

    [91, 56, 54, 52, 48, 48, 58, 63, 93]

This is, of course, is an array of numbers, not strictly a "byte array". Did you really mean a "byte array"?

Split the string into individual characters then map each character to its numeric code.

Per your added information about device.write I found this :

Writing to a device

Writing to a device is performed using the write call in a device handle. All writing is synchronous.

device.write([0x00, 0x01, 0x01, 0x05, 0xff, 0xff]);

on https://npmjs.org/package/node-hid

Assuming this is what you are using then my array above would work perfectly well :

device.write('[86400:?]'.split ('').map (function (c) { return c.charCodeAt (0); }));

As has been noted the 0x notation is just that, a notation. Whether you specify 0x0a or 10 or 012 (in octal) the value is the same.

Here's a node.js specific approach, taking advantage of the the Buffer class provided by the node standard lib.

https://nodejs.org/api/buffer.html#buffer_buffers_and_character_encodings

To get the byte (0-255) value:

Buffer.from('80', 'hex')[0];
// outputs 128

And to convert back:

Buffer.from([128]).toString('hex');
// outputs '80'

To convert to utf8:

Buffer.from('80', 'hex').toString('utf8');

Remember that a JavaScript code unit is 16 bits wide. Therefore the hex string form will be 4 digits per code unit.

usage:

var str = "\u6f22\u5b57"; // "\u6f22\u5b57" === "漢字"
alert(str.hexEncode().hexDecode());

String to hex form:

String.prototype.hexEncode = function(){
    var hex, i;

    var result = "";
    for (i=0; i<this.length; i++) {
        hex = this.charCodeAt(i).toString(16);
        result += ("000"+hex).slice(-4);
    }

    return result
}

Back again:

String.prototype.hexDecode = function(){
    var j;
    var hexes = this.match(/.{1,4}/g) || [];
    var back = "";
    for(j = 0; j<hexes.length; j++) {
        back += String.fromCharCode(parseInt(hexes[j], 16));
    }

    return back;
}

Here's something you can copy-paste in.

byteArray = new Uint8Array([181,143,16,173,231,56,63,149,181,185,224,124,84,230,123,36]);
function toHexString(byteArray) {
  return Array.prototype.map.call(byteArray, function(byte) {
    return ('0' + (byte & 0xFF).toString(16)).slice(-2);
  }).join('');
}
function toByteArray(hexString) {
  var result = [];
  for (var i = 0; i < hexString.length; i += 2) {
    result.push(parseInt(hexString.substr(i, 2), 16));
  }
  return result;
}
hexString = toHexString(byteArray);
byteArray = toByteArray(hexString);

From here/here.

In NodeJS, use Buffer to convert string to hex.

Buffer.from('hello world', 'utf8').toString('hex');

Simple example about how it works:

const bufferText = Buffer.from('hello world', 'utf8'); // or Buffer.from('hello world')
console.log(bufferText); // <Buffer 68 65 6c 6c 6f 20 77 6f 72 6c 64>

const text = bufferText.toString('hex');
// To get hex
console.log(text); // 68656c6c6f20776f726c64

console.log(bufferText.toString()); // or toString('utf8')
// hello world

//one single line
Buffer.from('hello world').toString('hex')

I'm not sure this is what you're after, but you can convert the string to an array of hex values like this:

var str = "00010203040506070809",
    a = [];

for (var i = 0; i < str.length; i += 2) {
    a.push("0x" + str.substr(i, 2));
}

console.log(a); // prints the array
console.log(a.join(" ")); // turn the array into a string of hex values
​console.log(parseInt(a[1], 16));​ // parse a particular hex number to a decimal value

A single liner : '[86400:?]'.split ('').map (function (c) { return c.charCodeAt (0); })returns [91, 56, 54, 52, 48, 48, 58, 63, 93]This is, of course, is an array of numbers, not strictly a “byte array”. Did you really mean a “byte array”? Split the string into individual characters then map each character to its numeric code.Per your added information about device.write I found this : Writing to a device Writing to a device is performed using the write call in a device handle. All writing is synchronous. device.write([0x00, 0x01, 0x01, 0x05, 0xff, 0xff]);on https://npmjs.org/package/node-hidAssuming this is what you are using then my array above would work perfectly well :device.write('[86400:?]'.split ('').map (function (c) { return c.charCodeAt (0); }));As has been noted the 0x notation is just that, a notation. Whether you specify 0x0a or 10 or 012 (in octal) the value is the same.