JavaScript：需要函数将包含二进制的字符串转换为十六进制，然后再转换回二进制

假设我有一个JavaScript字符串，其中包含二进制数据。可能是这样的：

var binary = '00001000010001000101010100001110';

我需要一些可靠的函数将其转换为十六进制字符串，然后再从十六进制转换回二进制字符串。我知道以下功能

// Convert binary to hexadecimal
var hex = parseInt(binaryCharacters, 2).toString(16);

// Convert hexadecimal to binary
var binary = parseInt(hex, 16).toString(2)

但我不知道如何一次转换整个字符串。我一次需要将每4个二进制位转换为一个十六进制字符，这理解正确吗？然后回到二进制，我循环遍历每个十六进制字符并再次转换为二进制

我已经找到了一些用JavaScript实现这一点的简单示例，但没有找到

非常感谢

这里有更有趣的函数。不一定是最干净或最高效的，但是：

// converts binary string to a hexadecimal string
// returns an object with key 'valid' to a boolean value, indicating
// if the string is a valid binary string.
// If 'valid' is true, the converted hex string can be obtained by
// the 'result' key of the returned object
function binaryToHex(s) {
    var i, k, part, accum, ret = '';
    for (i = s.length-1; i >= 3; i -= 4) {
        // extract out in substrings of 4 and convert to hex
        part = s.substr(i+1-4, 4);
        accum = 0;
        for (k = 0; k < 4; k += 1) {
            if (part[k] !== '0' && part[k] !== '1') {
                // invalid character
                return { valid: false };
            }
            // compute the length 4 substring
            accum = accum * 2 + parseInt(part[k], 10);
        }
        if (accum >= 10) {
            // 'A' to 'F'
            ret = String.fromCharCode(accum - 10 + 'A'.charCodeAt(0)) + ret;
        } else {
            // '0' to '9'
            ret = String(accum) + ret;
        }
    }
    // remaining characters, i = 0, 1, or 2
    if (i >= 0) {
        accum = 0;
        // convert from front
        for (k = 0; k <= i; k += 1) {
            if (s[k] !== '0' && s[k] !== '1') {
                return { valid: false };
            }
            accum = accum * 2 + parseInt(s[k], 10);
        }
        // 3 bits, value cannot exceed 2^3 - 1 = 7, just convert
        ret = String(accum) + ret;
    }
    return { valid: true, result: ret };
}

// converts hexadecimal string to a binary string
// returns an object with key 'valid' to a boolean value, indicating
// if the string is a valid hexadecimal string.
// If 'valid' is true, the converted binary string can be obtained by
// the 'result' key of the returned object
function hexToBinary(s) {
    var i, k, part, ret = '';
    // lookup table for easier conversion. '0' characters are padded for '1' to '7'
    var lookupTable = {
        '0': '0000', '1': '0001', '2': '0010', '3': '0011', '4': '0100',
        '5': '0101', '6': '0110', '7': '0111', '8': '1000', '9': '1001',
        'a': '1010', 'b': '1011', 'c': '1100', 'd': '1101',
        'e': '1110', 'f': '1111',
        'A': '1010', 'B': '1011', 'C': '1100', 'D': '1101',
        'E': '1110', 'F': '1111'
    };
    for (i = 0; i < s.length; i += 1) {
        if (lookupTable.hasOwnProperty(s[i])) {
            ret += lookupTable[s[i]];
        } else {
            return { valid: false };
        }
    }
    return { valid: true, result: ret };
}

//将二进制字符串转换为十六进制字符串
//将键为“valid”的对象返回为布尔值，表示
//如果字符串是有效的二进制字符串。
//如果“valid”为true，则可通过以下方式获得转换后的十六进制字符串：
//返回对象的“结果”键
函数binarytochex（s）{
变量i，k，部分，累计，ret=''；
对于（i=s.length-1；i>=3；i-=4）{
//从4的子字符串中提取并转换为十六进制
部分=s.substr（i+1-4,4）；
累计=0；
对于（k=0；k<4；k+=1）{
如果（部分[k]！='0'和部分[k]！='1'）{
//无效字符
返回{valid:false}；
}
//计算长度为4的子字符串
accum=accum*2+parseInt（第[k]部分，第10条）；
}
如果（累计>=10）{
//“A”到“F”
ret=String.fromCharCode（accum-10+A'.charCodeAt（0））+ret；
}否则{
//“0”到“9”
ret=字符串（累计）+ret；
}
}
//剩余字符，i=0、1或2
如果（i>=0）{
累计=0；
//从前面转换
对于（k=0；k我发现了一个算法，它有助于解释如何做。也有助于确认4位二进制到十六进制的映射。我想出了下面的代码来做这件事。我在网上找到的其他代码片段根本不起作用。让我知道你是否有任何改进。你甚至可能真的可以做一个直接的查找表使用维基百科上的信息会更快

var tools = {
    /**
     * Converts binary code to hexadecimal string
     * @param {string} binaryString A string containing binary numbers e.g. '01001101'
     * @return {string} A string containing the hexadecimal numbers
     */
    convertBinaryToHexadecimal: function(binaryString)
    {
        var output = '';

        // For every 4 bits in the binary string
        for (var i=0; i < binaryString.length; i+=4)
        {
            // Grab a chunk of 4 bits
            var bytes = binaryString.substr(i, 4);

            // Convert to decimal then hexadecimal
            var decimal = parseInt(bytes, 2);
            var hex = decimal.toString(16);

            // Uppercase all the letters and append to output
            output += hex.toUpperCase();
        }

        return output;      
    },

    /**
     * Converts hexadecimal code to binary code
     * @param {string} A string containing single digit hexadecimal numbers
     * @return {string} A string containing binary numbers
     */
    convertHexadecimalToBinary: function(hexString)
    {
        var output = '';

        // For each hexadecimal character
        for (var i=0; i < hexString.length; i++)
        {
            // Convert to decimal
            var decimal = parseInt(hexString.charAt(i), 16);

            // Convert to binary and add 0s onto the left as necessary to make up to 4 bits
            var binary = this.leftPadding(decimal.toString(2), '0', 4);

            // Append to string         
            output += binary;
        }

        return output;
    },

    /**
     * Left pad a string with a certain character to a total number of characters
     * @param {string} inputString The string to be padded
     * @param {string} padCharacter The character that the string should be padded with
     * @param {string} totalCharacters The length of string that's required
     * @returns {string} A string with characters appended to the front of it
     */
    leftPadding: function(inputString, padCharacter, totalCharacters)
    {
        // If the string is already the right length, just return it
        if (!inputString || !padCharacter || inputString.length >= totalCharacters)
        {
            return inputString;
        }

        // Work out how many extra characters we need to add to the string
        var charsToAdd = (totalCharacters - inputString.length)/padCharacter.length;

        // Add padding onto the string
        for (var i = 0; i < charsToAdd; i++)
        {
            inputString = padCharacter + inputString;
        }

        return inputString;
    }
};

var工具={
/**
*将二进制代码转换为十六进制字符串
*@param{string}binaryString包含二进制数的字符串，例如“01001101”
*@return{string}包含十六进制数的字符串
*/
convertBinaryToHexadecimal:函数（二进制字符串）
{
var输出=“”；
//对于二进制字符串中的每4位
对于（变量i=0；i=totalCharacters）
{
返回输入字符串；
}
//计算出需要向字符串中添加多少额外字符
var charsToAdd=（totalCharacters-inputString.length）/padCharacter.length；
//在字符串上添加填充
对于（变量i=0；i
要将箱子转换为十六进制和反转，我使用以下功能：


函数bintohex（）
{    
mybin=document.getElementById（'bin'）。值；
z=-1；数字=0；
对于（i=mybin.length；i>-1；i--）
{
//二进制字符串中的每一个1都转换为十进制并添加到数字中
如果（mybin.charAt（i）=“1”）{
数字+=数学功率（2，z）；
}
z+=1；
}
//Return正在将十进制转换为十六进制
document.getElementById（'result'）.innerHTML=number.toString（16）；
}
函数hextobin（）
{
mybin=“”；
///转换为十进制值并获取十进制sqrt的ceil
myhex=document.getElementById（'hex'）。值；
mydec=parseInt（myhex，16）；
i=Math.ceil（Math.sqrt（mydec））；
而（i>=0）
{
如果（Math.pow（2，i）为什么不使用

链接到jsfiddle

注:

在
bin2hex
中，如果要转换als
var binstr = "00001000010001000101010100001110"

function bin2hex(b) {
    return b.match(/.{4}/g).reduce(function(acc, i) {
        return acc + parseInt(i, 2).toString(16);
    }, '')
}

function hex2bin(h) {
    return h.split('').reduce(function(acc, i) {
        return acc + ('000' + parseInt(i, 16).toString(2)).substr(-4, 4);
    }, '')
}

console.log(binstr);
> 00001000010001000101010100001110
console.log(bin2hex(binstr));
> 0844550e
console.log(hex2bin(bin2hex(binstr)));
> 00001000010001000101010100001110