我正在一个相当大的循环中转换为十六进制字符串，所以我尝试了几种技术以找到最快的方法。我的要求是得到一个固定长度的字符串，并正确编码负值（-1=>ff..f）。

Simple.toString（16）不适合我，因为我需要正确编码负值。以下代码是迄今为止我在1-2字节值上测试的最快的代码（请注意，符号定义了要获得的输出符号的数量，即对于4字节整数，它应该等于8）：

var hex = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'];
function getHexRepresentation(num, symbols) {
    var result = '';
    while (symbols--) {
        result = hex[num & 0xF] + result;
        num >>= 4;
    }
    return result;
}

它在1-2字节的数字上比.toString（16）执行得更快，在更大的数字上（当符号>=6时）执行得更慢，但仍应优于正确编码负值的方法。

如何在JavaScript中将十进制转换为十六进制

我没能找到一个非常干净/简单的十进制到十六进制的转换，它不涉及一堆函数和数组。。。所以我必须自己做这个。

function DecToHex(decimal) { // Data (decimal)

    length = -1;    // Base string length
    string = '';    // Source 'string'

    characters = [ '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' ]; // character array

    do { // Grab each nibble in reverse order because JavaScript has no unsigned left shift

        string += characters[decimal & 0xF];   // Mask byte, get that character
        ++length;                              // Increment to length of string

    } while (decimal >>>= 4); // For next character shift right 4 bits, or break on 0

    decimal += 'x'; // Convert that 0 into a hex prefix string -> '0x'

    do
        decimal += string[length];
    while (length--); // Flip string forwards, with the prefixed '0x'

    return (decimal); // return (hexadecimal);
}

/* Original: */

D = 3678;    // Data (decimal)
C = 0xF;    // Check
A = D;        // Accumulate
B = -1;        // Base string length
S = '';        // Source 'string'
H = '0x';    // Destination 'string'

do {
    ++B;
    A& = C;

    switch(A) {
        case 0xA: A='A'
        break;

        case 0xB: A='B'
        break;

        case 0xC: A='C'
        break;

        case 0xD: A='D'
        break;

        case 0xE: A='E'
        break;

        case 0xF: A='F'
        break;

        A = (A);
    }
    S += A;

    D >>>= 0x04;
    A = D;
} while(D)

do
    H += S[B];
while (B--)

S = B = A = C = D; // Zero out variables
alert(H);    // H: holds hexadecimal equivalent

下面的代码将十进制值d转换为十六进制。它还允许您向十六进制结果添加填充。因此默认情况下0将变为00。

function decimalToHex(d, padding) {
    var hex = Number(d).toString(16);
    padding = typeof (padding) === "undefined" || padding === null ? padding = 2 : padding;

    while (hex.length < padding) {
        hex = "0" + hex;
    }

    return hex;
}

没有循环：

function decimalToHex(d) {
  var hex = Number(d).toString(16);
  hex = "000000".substr(0, 6 - hex.length) + hex;
  return hex;
}

// Or "#000000".substr(0, 7 - hex.length) + hex;
// Or whatever
// *Thanks to MSDN

另外，不使用必须评估的循环测试不是更好吗？

例如，代替：

for (var i = 0; i < hex.length; i++){}

have

for (var i = 0, var j = hex.length; i < j; i++){}

使用以下命令将数字转换为十六进制字符串：

hexString = yourNumber.toString(16);

并通过以下方式反转该过程：

yourNumber = parseInt(hexString, 16);

接受的答案没有考虑返回的十六进制代码的单个数字。可通过以下方式轻松调整：

function numHex(s)
{
    var a = s.toString(16);
    if ((a.length % 2) > 0) {
        a = "0" + a;
    }
    return a;
}

and

function strHex(s)
{
    var a = "";
    for (var i=0; i<s.length; i++) {
        a = a + numHex(s.charCodeAt(i));
    }

    return a;
}

我相信上面的答案已经被其他人以这样或那样的形式发布了很多次。我将它们包装在toHex（）函数中，如下所示：

function toHex(s)
{
    var re = new RegExp(/^\s*(\+|-)?((\d+(\.\d+)?)|(\.\d+))\s*$/);

    if (re.test(s)) {
        return '#' + strHex( s.toString());
    }
    else {
        return 'A' + strHex(s);
    }
}

注意，数字正则表达式来自10+有用的JavaScript正则表达式函数，以提高web应用程序的效率。

更新：在测试了几次之后，我发现了一个错误（RegExp中的双引号），所以我修复了这个错误。然而！经过相当多的测试和阅读了almaz的帖子后，我意识到我无法得到负数。

此外，我对此进行了一些阅读，因为所有JavaScript数字都存储为64位单词，无论是什么，我尝试修改numHex代码以获得64位单词。但事实证明你不能这样做。如果你把“3.14159265”作为一个数字放入一个变量中，你只能得到“3”，因为分数部分只能通过将数字重复乘以十（IE:10.0）来获得。或者换句话说，十六进制值0xF会导致浮点值在“与”运算之前转换为整数，从而删除句点后面的所有内容。而不是将该值作为一个整体（即：3.14159265），并将浮点值与0xF值进行“与”运算。

因此，在这种情况下，最好的方法是将3.14159265转换为字符串，然后再转换字符串。由于上述原因，它也使得转换负数变得容易，因为负号正好变成值前面的0x26。

所以我所做的是确定变量包含一个数字——只需将其转换为字符串并转换字符串。这对每个人都意味着，在服务器端，您需要取消对传入字符串的加热，然后确定传入的信息是数字。只需在数字前面加上一个“#”，在返回的字符串前面加上“a”，就可以很容易地做到这一点。请参见toHex（）函数。

玩得高兴

经过又一年的思考，我决定“toHex”函数（我还有一个“fromHex”功能）确实需要修改。整个问题是“我如何才能更有效地执行此操作？”我决定，to/from十六进制函数不应关心某个东西是否为小数部分，但同时它应确保字符串中包含小数部分。

于是，问题变成了，“你怎么知道你在使用十六进制字符串？”。答案很简单。使用全世界公认的标准字符串前信息。

换句话说，使用“0x”。所以现在我的toHex函数看看它是否已经存在，如果已经存在-它只是返回发送给它的字符串。否则，它会转换字符串、数字等。以下是修改后的toHex函数：

/////////////////////////////////////////////////////////////////////////////
//  toHex().  Convert an ASCII string to hexadecimal.
/////////////////////////////////////////////////////////////////////////////
toHex(s)
{
    if (s.substr(0,2).toLowerCase() == "0x") {
        return s;
    }

    var l = "0123456789ABCDEF";
    var o = "";

    if (typeof s != "string") {
        s = s.toString();
    }
    for (var i=0; i<s.length; i++) {
        var c = s.charCodeAt(i);

        o = o + l.substr((c>>4),1) + l.substr((c & 0x0f),1);
    }

    return "0x" + o;
}

这是一个非常快速的函数，它考虑了个位数、浮点数，甚至可以检查用户是否正在发送一个十六进制值以再次进行十六进制运算。它只使用四个函数调用，其中只有两个在循环中。要取消十六进制值，请执行以下操作：

/////////////////////////////////////////////////////////////////////////////
//  fromHex().  Convert a hex string to ASCII text.
/////////////////////////////////////////////////////////////////////////////
fromHex(s)
{
    var start = 0;
    var o = "";

    if (s.substr(0,2).toLowerCase() == "0x") {
        start = 2;
    }

    if (typeof s != "string") {
        s = s.toString();
    }
    for (var i=start; i<s.length; i+=2) {
        var c = s.substr(i, 2);

        o = o + String.fromCharCode(parseInt(c, 16));
    }

    return o;
}

与toHex（）函数一样，fromHex（（）函数首先查找“0x”，然后如果传入的信息不是字符串，则将其转换为字符串。我不知道这怎么会不是一个字符串-但以防万一-我检查了一下。然后，该函数继续执行，抓取两个字符并将其转换为ASCII字符。如果您希望它转换Unicode，则需要将循环更改为每次四（4）个字符。但是，您还需要确保字符串不能被4整除。如果是-则是标准的十六进制字符串。（记住字符串前面有“0x”。）

一个简单的测试脚本显示，当转换为字符串时，-3.14159265仍然是-3.1415925。

<?php

    echo <<<EOD
<html>
    <head><title>Test</title>
        <script>
            var a = -3.14159265;
            alert( "A = " + a );
            var b = a.toString();
            alert( "B = " + b );
        </script>
    </head>
    <body>
    </body>
</html>
EOD;

?>

由于JavaScript在toString（）函数方面的工作方式，所有这些以前引起问题的问题都可以消除。现在，所有字符串和数字都可以轻松转换。此外，像对象这样的东西会导致JavaScript本身生成错误。我相信这是最好的。唯一的改进是W3C只在JavaScript中包含toHex（）和fromHex（（）函数。