convert hex to binary in javascript

Unfortunately, previous answers seem not to be working with very large values (e.g., 512 bits so common in cryptography). This solution may be a bit slower, but it guarantees dealing with input of any length.

function hex2bin(hex){
    hex = hex.replace("0x", "").toLowerCase();
    var out = "";
    for(var c of hex) {
        switch(c) {
            case '0': out += "0000"; break;
            case '1': out += "0001"; break;
            case '2': out += "0010"; break;
            case '3': out += "0011"; break;
            case '4': out += "0100"; break;
            case '5': out += "0101"; break;
            case '6': out += "0110"; break;
            case '7': out += "0111"; break;
            case '8': out += "1000"; break;
            case '9': out += "1001"; break;
            case 'a': out += "1010"; break;
            case 'b': out += "1011"; break;
            case 'c': out += "1100"; break;
            case 'd': out += "1101"; break;
            case 'e': out += "1110"; break;
            case 'f': out += "1111"; break;
            default: return "";
        }
    }

    return out;
}

The simplest implementation

const hex2bin = (data) => data.split('').map(i => 
parseInt(i, 16).toString(2).padStart(4, '0')).join('');

This work for me.

function hex2bin(hexSource) {
    var bin = '';
    for (var i=0;i<hexSource.length;i=i+2) {
        bin += String.fromCharCode(hexdec(hexSource.substr(i,2)));
    }
    return bin;
}

function hexdec(hexString) {
    hexString = (hexString + '').replace(/[^a-f0-9]/gi, '')
    return parseInt(hexString, 16)
}

this might be faster method, concept is considering integer's capacity we can divide hex string into blocks of 8 chars instead of 1 char:

function hexToBinary(hex) {
    var binary = "";
    var remainingSize = hex.length;
    for (var p = 0; p < hex.length/8; p++) {
        //In case remaining hex length (or initial) is not multiple of 8
        var blockSize = remainingSize < 8 ? remainingSize  : 8;

        binary += parseInt(hex.substr(p * 8, blockSize), 16).toString(2).padStart(blockSize*4,"0");

        remainingSize -= blockSize;
    }
    return binary;
}

I agree for hex to binary going character by character isn't the fastest or most efficient, but I think it's difficult to do that and still have readable code. I think these two are good starting points for those less familiar.

function hex2bin(hex) {
  let bin = "";
  let bitsInHex = 4;

  Array.from(hex).forEach(
    function (char) {
      let currentBin = parseInt(char, 16).toString(2);

      if (currentBin.length < bitsInHex) {
        let padding = "0".repeat(bitsInHex-currentBin.length);
        currentBin = padding + currentBin;
      }

      bin += currentBin;
    }
  );

  return bin;
}

function bin2hex(bin) {
  let hex = "";
  let bitsInHex = 4;

  for (let i = 0; i < bin.length; i = i + bitsInHex) {
    let eightBits = bin.substr(i, bitsInHex);
    let currentHex = (parseInt(eightBits, 2)).toString(16).toUpperCase();
    hex += currentHex;
  }

  return hex;
}

For some reason, Javascript gives only 0000 if the character length is greater than 12. I am self-taught JS, so don't know the reason.

But I have a workaround for this problem. Just divided the original string into an array of smaller chunks, and then find their binary value.

function hex2bin(hex) {
    let chunks = hex.match(/.{1,8}/g), bin = ''
    chunks.forEach(c => (bin += parseInt(c, 16).toString(2)))
    bin = bin.padStart(4, '0')
    return bin
}

I think this would be much easier to implement than to use individual binary values of hex as mentioned in this solution.
My solution is somewhat similar to this