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

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

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

Further, you cannot simply push a value of type Integer to a byte array. Integers are represented with 32 bit (4 bytes), so you first have to "split" such number while computing the single bytes one by one:

intToByteArray = function(intToConvert) {
    var byteArray = new Array(4)

    for(var i = 0; i < byteArray.length; i++) {
        var byte = intToConvert & 0xff;
        byteArray[i] = byte;
        intToConvert = (intToConvert - byte) / 256 ;
    }

    return byteArray;
};     

Demonstration of back and forth conversion (JS-Fiddle)

Explanation of code lines

1. At first, we declare an array of bytes:

   var byteArray = new Array(4)
   

   Array: [00000000, 00000000, 00000000, 00000000]

2. By using the bit-wise AND operator &, we "capture" the first 8 bits while assigning the resulting value to a new variable:

   var byte = intToConvert & 0xff;
   

   What's happening with our variables:

   intToConvert: 10101010 10101010 10101010 10101010
   
   AND "0xff":   11111111 -------- -------- --------
   
   Results in:   10101010
   

3. Then, we put the resulting single byte to the actual index of the temporary byte array:

   byteArray[i] = byte;
   

   Array: [10101010, 00000000, 00000000, 00000000]

4. Now, we only have to subtract the value just added to the array and remove one byte from the integer variable:

   intToConvert = (intToConvert - byte) / 256 ;
   

   2863311530 - 170 = 2863311360
   2863311360 / 256 = 11184810

   2863311360 => 10101010 10101010 10101010 00000000
     11184810 =>          10101010 10101010 10101010
   

Continuing with this loop will transfer byte by byte from the Integer to the temporary byte array. So we will get a byte array of 4 single bytes representing one integer or two Character of the hexadecimal String.

How to convert byte to Integer is well explained here.
So your updated hex2bin(String) should look like:

function hex2bin(hexString) {
    var bytes = new Array(hexString.length / 2);

    for(var i = 0; i < hexString.length-1; i+=2) {
        bytes.push(
            intToByteArray(
                parseInt(hexString.substr(i, 2), 16)
            )
        );
    }

    StringBuilder sb = new StringBuilder(bytes.length * 8);
    for(byte b : bytes) {
        sb.append(Integer.toBinaryString((b & 0xFF) + 0x100).substring(1));    
    }
    return sb.toString();
}

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.