关于十六进制：如何在javascript中将十进制转换为十六进制


How to convert decimal to hexadecimal in JavaScript

在JavaScript中，如何将十进制值转换为其十六进制等效值？

相关讨论

将数字转换为十六进制字符串：

1
hexString = yourNumber.toString(16);

并用以下方法逆转过程：

1
yourNumber = parseInt(hexString, 16);
相关讨论

如果您需要处理位字段或32位颜色之类的事情，那么您需要处理有符号数字。javascript函数toString(16)将返回一个负的十六进制数，这通常不是您想要的。这个函数做了一些疯狂的加法，使它成为一个正数。

1
2
3
4
5
6
7
8
9
10
11
12
function decimalToHexString(number)
{
  if (number < 0)
  {
    number = 0xFFFFFFFF + number + 1;
  }

  return number.toString(16).toUpperCase();
}

console.log(decimalToHexString(27));
console.log(decimalToHexString(48.6));

相关讨论

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

1
2
3
4
5
6
7
8
9
10
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;
}
相关讨论

1
2
3
function toHex(d) {
    return  ("0"+(Number(d).toString(16))).slice(-2).toUpperCase()
}
相关讨论

填充：

1
2
3
function dec2hex(i) {
   return (i+0x10000).toString(16).substr(-4).toUpperCase();
}
相关讨论

为了完成此操作，如果您想要负数的两个补十六进制表示，可以使用零填充右移位>>>运算符。例如：

1
2
3
4
5
> (-1).toString(16)
"-1"

> ((-2)>>>0).toString(16)
"fffffffe"

但是有一个限制：javascript按位运算符将其操作数视为32位的序列，也就是说，您得到32位2的补码。

相关讨论

没有回路：

1
2
3
4
5
6
7
8
9
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

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

例如，而不是：

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

有

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

将这些关于rgb值的好主意结合到十六进制函数中(在其他地方为html/css添加#)：

1
2
3
4
5
6
function rgb2hex(r,g,b) {
    if (g !== undefined)
        return Number(0x1000000 + r*0x10000 + g*0x100 + b).toString(16).substring(1);
    else
        return Number(0x1000000 + r[0]*0x10000 + r[1]*0x100 + r[2]).toString(16).substring(1);
}
相关讨论

接受的答案没有考虑到返回十六进制代码的单个数字。这很容易通过以下方式进行调整：好的。

1
2
3
4
5
6
7
8
function numHex(s)
{
    var a = s.toString(16);
    if ((a.length % 2) > 0) {
        a ="0" + a;
    }
    return a;
}

和好的。

1
2
3
4
5
6
7
8
9
function strHex(s)
{
    var a ="";
    for (var i=0; i<s.length; i++) {
        a = a + numHex(s.charCodeAt(i));
    }

    return a;
}

我相信上述答案已经被其他人以一种或另一种形式发布了很多次。我用tohex()函数包装这些文件，如下所示：好的。

1
2
3
4
5
6
7
8
9
10
11
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中的双引号)，所以我修复了这个错误。然而！经过一段时间的测试，读了阿尔玛兹的文章后，我意识到我不能让负数发挥作用。好的。

此外，我读了一些关于这个的内容，因为所有的javascript数字都存储为64位字，不管怎样，我尝试修改numhex代码来获得64位字。但事实证明你做不到。如果你把"3.14159265"作为一个数字放入一个变量中，你所能得到的就是"3"，因为分数部分只能通过将数字乘以10(即：10.0)来访问。或者换一种说法，十六进制的0xF值会导致浮点值在被求和之前被转换为整数，这会删除句点后面的所有内容。而不是将该值作为一个整体(即：3.14159265)并将浮点值与0xF值相加。好的。

因此，在本例中，最好的做法是将3.14159265转换为字符串，然后只转换字符串。由于上面的原因，它也使得转换负数变得容易，因为减号在值的前面变成了0x26。好的。

所以我所做的是确定变量包含一个数字-只需将其转换为字符串并转换字符串。这意味着对于服务器端的所有人来说，您需要取消对传入字符串的加热，然后确定传入信息是数字的。只需在数字前面加一个""，在返回的字符串前面加一个"a"，就可以轻松地做到这一点。请参见tohex()函数。好的。

玩得高兴！好的。

经过一年多的思考，我决定"tohex"函数(我还有一个"fromhex"函数)确实需要修改。整个问题是"我如何才能更有效地做到这一点？"我决定，to/from十六进制函数不应该关心某个部分是否是小数部分，但同时它应该确保字符串中包含小数部分。好的。

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

换句话说-使用"0x"。所以现在我的tohex函数检查它是否已经存在，如果已经存在，它只返回发送给它的字符串。否则，它将转换字符串、数字等。以下是修改后的十六进制函数：///////////////////////////////////////////////////////////////////////////////To()。将ASCII字符串转换为十六进制。/////////////////////////////////////////////////////////////////////////////托克斯(S){if(s.substr(0,2).tolowercase()="0x")。{返回S；}好的。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
    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;
}

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
/////////////////////////////////////////////////////////////////////////////
//  fromHex().  Convert a hex string to ASCII text.
/////////////////////////////////////////////////////////////////////////////
fromHex(s)
{
    var start = 0;
    var o ="";

    if (s.substr(0,2) =="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.14159265。好的。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
<?php

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

?>

由于javascript在toString()函数中的工作方式，所有这些问题都可以在导致问题之前消除。现在所有的字符串和数字都可以很容易地转换。此外，对象等内容将导致JavaScript本身生成错误。我相信这是最好的。剩下的唯一改进是W3C只在javascript中包含tohex()和fromhex()函数。好的。好啊。

相关讨论

1
2
var number = 3200;
var hexString = number.toString(16);

16是基数，十六进制数中有16个值：—)

约束/填充到一组字符数：

1
2
3
function decimalToHex(decimal, chars) {
    return (decimal + Math.pow(16, chars)).toString(16).slice(-chars).toUpperCase();
}
相关讨论

1
2
3
4
5
6
7
8
9
function dec2hex(i)
{
  var result ="0000";
  if      (i >= 0    && i <= 15)    { result ="000" + i.toString(16); }
  else if (i >= 16   && i <= 255)   { result ="00"  + i.toString(16); }
  else if (i >= 256  && i <= 4095)  { result ="0"   + i.toString(16); }
  else if (i >= 4096 && i <= 65535) { result =         i.toString(16); }
  return result
}
相关讨论

如果要将数字转换为rgba颜色值的十六进制表示形式，我发现这是以下几个提示中最有用的组合：

1
2
3
4
5
6
function toHexString(n) {
    if(n < 0) {
        n = 0xFFFFFFFF + n + 1;
    }
    return"0x" + ("00000000" + n.toString(16).toUpperCase()).substr(-8);
}

Afaik评论57807是错误的，应该是：var hex=数字(d).ToString(16)；而不是var hex=parseint(d，16)；

1
2
3
4
5
6
7
8
9
10
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;
}

对于任何感兴趣的人，这里有一个比较这个问题的大多数答案的jsiddle。

以下是我最终采用的方法：

1
2
3
function decToHex(dec) {
    return (dec + Math.pow(16, 6)).toString(16).substr(-6);
}

另外，请记住，如果要将十进制转换为十六进制以在CSS中用作颜色数据类型，您可能更喜欢从十进制中提取RGB值并使用rgb()。

例如(jspiddle)：

1
2
3
4
5
var c = 4210330; // your color in decimal format
var rgb = [(c & 0xff0000) >> 16,  (c & 0x00ff00) >> 8,  (c & 0x0000ff)];

// assuming you're using jQuery...
$("#some-element").css("color","rgb(" + rgb +")");

这将#some-element的css color属性设置为rgb(64, 62, 154)属性。

您还可以检查下面的jfiddle示例或堆栈溢出的javascript示例代码。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
'use strict';

var convertBase = function () {

    function convertBase(baseFrom, baseTo) {
        return function (num) {
            return parseInt(num, baseFrom).toString(baseTo);

        };
    }

    // Decimal to hexadecimal
    convertBase.dec2hex = convertBase(10, 16);
    return convertBase;
}();

alert(convertBase.dec2hex('42')); // '2a'

如果数字是负数？

这是我的版本。

1
2
3
4
5
function hexdec (hex_string) {
    hex_string=((hex_string.charAt(1)!='X' && hex_string.charAt(1)!='x')?hex_string='0X'+hex_string : hex_string);
    hex_string=(hex_string.charAt(2)<8 ? hex_string =hex_string-0x00000000 : hex_string=hex_string-0xFFFFFFFF-1);
    return parseInt(hex_string, 10);
}

以下是经过裁剪的ECMAScript 6版本：

1
2
3
4
5
6
7
8
9
10
11
12
13
const convert = {
  bin2dec : s => parseInt(s, 2).toString(10),
  bin2hex : s => parseInt(s, 2).toString(16),
  dec2bin : s => parseInt(s, 10).toString(2),
  dec2hex : s => parseInt(s, 10).toString(16),
  hex2bin : s => parseInt(s, 16).toString(2),
  hex2dec : s => parseInt(s, 16).toString(10)
};

convert.bin2dec('111'); // '7'
convert.dec2hex('42');  // '2a'
convert.hex2bin('f8');  // '11111000'
convert.dec2bin('22');  // '10110'
相关讨论

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
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
相关讨论

正如公认的答案所述，从十进制转换为十六进制的最简单方法是var hex = dec.toString(16)。但是，您可能更喜欢添加字符串转换，因为它可以确保像"12".toString(16)这样的字符串表示正确工作。

1
2
// Avoids a hard-to-track-down bug by returning `c` instead of `12`
(+"12").toString(16);

为了逆转这个过程，您也可以使用下面的解决方案，因为它甚至更短。

1
var dec = +("0x" + hex);

谷歌Chrome和火狐的速度似乎较慢，但Opera的速度却明显更快。请参阅http://jspef.com/hex-to-dec。

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

简单的.toString(16)对我来说不起作用，因为我需要负的值进行适当的编码。以下代码是迄今为止我对1-2字节值所测试的最快的代码(请注意，symbols定义了您想要得到的输出符号数，即对于4字节整数，它应该等于8)：

1
2
3
4
5
6
7
8
9
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)快，在较大的数上(当symbols大于等于6)慢，但仍应优于正确编码负值的方法。

总而言之；

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
function toHex(i, pad) {

  if (typeof(pad) === 'undefined' || pad === null) {
    pad = 2;
  }

  var strToParse = i.toString(16);

  while (strToParse.length < pad) {
    strToParse ="0" + strToParse;
  }

  var finalVal =  parseInt(strToParse, 16);

  if ( finalVal < 0 ) {
    finalVal = 0xFFFFFFFF + finalVal + 1;
  }

  return finalVal;
}

但是，如果不需要在末尾将其转换回整数(例如，对于颜色)，那么只要确保值不是负数就足够了。

如果您希望转换为"完整"的JavaScript或CSS表示形式，可以使用如下内容：

1
2
3
4
5
6
7
8
9
10
11
12
  numToHex = function(num) {
    var r=((0xff0000&num)>>16).toString(16),
        g=((0x00ff00&num)>>8).toString(16),
        b=(0x0000ff&num).toString(16);
    if (r.length==1) { r = '0'+r; }
    if (g.length==1) { g = '0'+g; }
    if (b.length==1) { b = '0'+b; }
    return '0x'+r+g+b;                 // ('#' instead of'0x' for CSS)
  };

  var dec = 5974678;
  console.log( numToHex(dec) );        // 0x5b2a96

我没有找到一个明确的答案，没有检查它是负的还是正的，它使用了两个补码(包括负数)。为此，我将我的解决方案显示为一个字节：

1
((0xFF + number +1) & 0x0FF).toString(16);

您可以将此指令用于任何数字字节，只需在相应的位置添加FF。例如，到两个字节：

1
((0xFFFF + number +1) & 0x0FFFF).toString(16);

如果要将数组整数强制转换为字符串十六进制：

1
2
3
4
s ="";
for(var i = 0; i < arrayNumber.length; ++i) {
    s += ((0xFF + arrayNumber[i] +1) & 0x0FF).toString(16);
}

您可以在ecmascript 6中执行类似的操作：

1
const toHex = num => (num).toString(16).toUpperCase();

我的解决方案是：

1
2
3
hex = function(number) {
  return '0x' + Math.abs(number).toString(16);
}

问题是："如何在javascript中将十进制转换为十六进制"。虽然问题没有指定十六进制字符串应该以0x前缀开头，但是编写代码的任何人都应该知道在十六进制代码中添加了0x，以区分十六进制代码与编程标识符和其他数字(1234可以是十六进制、十进制甚至八进制)。

因此，为了正确回答这个问题，为了编写脚本，必须添加0x前缀。

abs(n)函数将负片转换成正片，作为一个额外的好处，它看起来不像是有人用木头削片机削的。

我想要的答案应该有一个字段宽度说明符，所以我们可以例如显示8/16/32/64位值，就像在十六进制编辑应用程序中看到的那样。这才是真正正确的答案。

相关讨论