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


Answers:


2473

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

hexString = yourNumber.toString(16);

并通过以下步骤逆转该过程:

yourNumber = parseInt(hexString, 16);

42
在这种情况下,yourNum是一个十六进制字符串。例如(255).toString(16)=='ff'&& parseInt('ff',16)== 255
Prestaul

8
@forste,如果使用此技术将javascript Number(即Number对象,在ECMA脚本中为Double)转换为十六进制并返回,则不会“松散精度”。您链接的问题专门引用的数字太大而无法放入Double中(因此问题中的字符串表示形式)。如果您有一个号码,那么它将起作用。如果您的物件太大而无法成为javascript Number对象(Double),那么您将不得不寻找其他物件。
Prestaul

12
@Derek,我有一个心理问题,不允许我容忍不必要的括号... @ everyone-else,yourNumber是一个变量。如果要使用数字文字,则必须执行类似的操作(45).toString(16),但是如果您要对数字进行硬编码,则请自己(45).toString(16)将其写为十六进制字符串... 将始终相等'2d',所以不要浪费cpu循环找出答案。
Prestaul 2012年

21
@Prestaul“不要浪费CPU周期来弄清楚这一点”-这就是所谓的过早优化。除非JavaScript在286上运行,否则我会怀疑开销问题。此外,“ 45”可能是程序员必须能够识别的不可思议的数字(例如超时持续时间(以秒为单位)),而“ 2d”,那么谁会认识到呢?
Dejay Clayton 2014年

47
如果您不喜欢括号,可以使用一个额外的圆点:42..toString(16)
Thomas Watson

142

如果需要处理位字段或32位颜色之类的内容,则需要处理带符号的数字。JavaScript函数toString(16)将返回负十六进制数,通常这不是您想要的。此功能做了一些疯狂的添加,使其成为正数。

function decimalToHexString(number)
{
  if (number < 0)
  {
    number = 0xFFFFFFFF + number + 1;
  }

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

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


5
是两个的补充吗?
朱利安

2
通常不需要这种转换,因为JavaScript可以将所有32位位字段表示为无符号数字(请参见Number.MAX_SAFE_INTEGER)。出于相同的原因,可以将转换为无符号的形式写为:number = 0x100000000 + number;
Johannes Matokic

3
关于我以前的评论的简短说明:虽然十六进制表示形式适用于Number.MAX_SAFE_INTEGER以内的数字,但不适用于按位运算(通常用于创建32位颜色)。按位运算的结果始终是一个有符号的32位整数。因此,> = 2 ^ 31的按位结果为负,并且0x100000000 | 0 === 0
约翰Matokic

25
您可以使用>>>运算符将数字转换为无符号表示形式,例如((-3253) >>> 0).toString(16)return "fffff34b"
csharpfolk

1
+1进行有用的添加,但是如果要将数字转换为其他表示法,则所有数字通常已经“通常”为正,否则您希望得到负数。
卡尔·史密斯,

82

下面的代码将十进制值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;
}

5
这将无法正确处理负值。decimalToHex(-6,4)将返回00-6。
JonMR 2010年

3
浮点数也有问题,但是放入Math.round()可以解决该问题。(+1)
迈克尔-克莱·史基(Where's Clay Shirky)2012年

我从数组(“ 255,0,55”等)“拉”数字,而.toString(16)无法正常工作。我得到的都是相同的数字!我在前面添加了“数字”功能,现在可以使用了!仅仅花了大约四个小时才找到解决方案!
Cristofayre,

65
function toHex(d) {
    return  ("0"+(Number(d).toString(16))).slice(-2).toUpperCase()
}

1
function hexRep(number, width) { return (number+Math.pow(16, precision)).toString(16).slice(-width); }
罗里

2
扩展它并不难,您可以在其中用.slice(-number)分割最后的数字。如果您在前面添加更多零,它将正常工作。
Ta

19
ES6 const hex = d => Number(d).toString(16).padStart(2, '0')😁
宁范

39

为了完整起见,如果要用负数的二进制补码十六进制表示形式,则可以使用zero-fill-right shift >>>运算符。例如:

> (-1).toString(16)
"-1"

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

但是,存在一个局限性:JavaScript按位运算符将其操作数视为32位序列,也就是说,您获得了32位二进制补码。


2
这是迄今为止这个问题最有价值的答案:)
albertjan

仔细研究所有问题,因为C# number to hexadecimal与产生不同的结果Javascript number to hexadecimal。看来Javascript存在负数问题。这个答案似乎是解决问题的方法。
goamn

这非常有帮助,谢谢!我将其用于RGB颜色,因此要获得24位变体,请砍掉前两个字符(多余的FF)((-2)>>>0).toString(16).substring(2)
antonyh


19

没有循环:

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++){}

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

19

将这些好点子结合起来,实现RGB值到十六进制的功能(#为HTML / CSS 添加其他内容):

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

谢谢你!我想在很久以前发表评论。这是我回答的关键。stackoverflow.com/questions/5560248/...
皮条客Trizkit

16

接受的答案未考虑返回的一位数字的十六进制代码。这很容易通过以下方式进行调整:

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

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”,因为小数部分只能通过将数字重复乘以10(IE:10.0)来访问。或者换种说法- 十六进制值0xF导致将浮点值与AND运算之前转换为整数,从而删除了句点之后的所有内容。而不是将值作为一个整体(即: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)个字符。但是然后,您还需要确保字符串不能被四整除。如果是-则它是标准的十六进制字符串。(请记住,该字符串的前面带有“ 0x”。)

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

<?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()函数。


我认为您仍有工作要做…… 例如,在您可能不需要if( s.substr(0,2)之前if (typeof s != "string")。我返回的东西也不是我所期望的(toHex(0x1f635)给出"0x313238353635")。没有进一步调查。
ruffin

我相信你是不对的。您的示例使用的十六进制字符串不是字符串-而是数字。因此1f635会以这种方式出现。如果您输入“ 0x1f635”,结果将有所不同。(即:例程将刚刚返回您发送给例程的十六进制数字。):-)
Mark Manning

第一点是,您不能在非字符串上使用substrtoLowerCase…因此typeof需要尽快解决,或者,如果您希望toHex在此处使用非字符串,则应typeof完全删除支票。合理?也就是说,如果我在这里使用代码而不进行编辑,然后调用toHex(0x1f635),我会得到的Uncaught TypeError: s.substr is not a function。如果我更早地移动了强制转换的字符串,那您是对的,数字可能首先强制转换为十进制,然后事情就会发生变化。如果s不是字符串,那当然意味着您不能在此处进行简单的转换。
鲁芬

实际上,在XP下可以正常工作。对Javascript进行了许多更新,这些更新使Javascript被转换。这将引发异常。在XP下它可以运行jusr。至少对我来说。在类型转换世界中,放置“ if(typeof s ==“ string” && s.substr(0,2)==“ 0x”){return s;}”是合适的。但是ox1f635仍然不是字符串。:-)
Mark Manning

12
var number = 3200;
var hexString = number.toString(16);

16是基数,十六进制数中有16个值:-)


12

对于任何有兴趣的人,这里是一个JSFiddle,它比较了对此问题给出的大多数答案

这是我最终使用的方法:

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

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

例如(JSFiddle):

let c = 4210330 // your color in decimal format
let rgb = [(c & 0xff0000) >> 16,  (c & 0x00ff00) >> 8,  (c & 0x0000ff)]

// Vanilla JS:
document..getElementById('some-element').style.color = 'rgb(' + rgb + ')'
// jQuery:
$('#some-element').css('color', 'rgb(' + rgb + ')')

这会将#some-elementCSS color属性设置为rgb(64, 62, 154)


10

限制/填充到一定数量的字符:

function decimalToHex(decimal, chars) {
    return (decimal + Math.pow(16, chars)).toString(16).slice(-chars).toUpperCase();
}

2
这会将数字转换为字符串十六进制并填充前导零,这很漂亮!
哥顿

10

这是精简的ECMAScript 6版本:

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'

如果您的环境或情况允许您使用@HypersoftSystems,则强烈不同意@ 6,然后使用ES6。并非每个脚本都需要在旧版Bootleg解释器中运行,还有babel的存在是有原因的。最后,如果您知道ES6,它会更清晰易读。那就是说,提供标准的JS答案可能会帮助更多的人,但是考虑到较旧的JS版本还有其他答案,拥有ES6答案仅是有益的,绝对不需要“这就是我今天所做的”。
WiR3D

观点不成立,因此您的“论据”无效。@ WiR3D
Hypersoft Systems

@HypersoftSystems与您一样有效(如果不是更多的话),因为您的观点是有根据的,并将上下文限制为在大多数现代应用程序中可能无效的上下文。
WiR3D

用户错误:“只是认为”,“可能”和“最多”。
Hypersoft Systems

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
}

1
+1谢谢!使用CSS时,toString(16)很重要,因此您会得到FF0000之类的结果
Tyler Egeto 2011年

7
使用css(或svg,它接受css样式的颜色规范)时,您可以通过书写color: rgb(r,g,b)其中rg和b是十进制数字来回避整个问题。
–telent

1
应该是:function decimalToHexString(i) { var result = "00"; 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 }
艾库特·切维克(AykutÇevik)2011年

9

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

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

8

AFAIK 评论5780​​7是错误的,应类似于: var hex = Number(d).toString(16); 而不是 var hex = parseInt(d,16);

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;
}

6

如果数字是负数?

这是我的版本。

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

5

我正在一个相当大的循环中进行到十六进制字符串的转换,所以我尝试了几种技巧以找到最快的一种。我的要求是使用固定长度的字符串,并正确编码负值(-1 => ff..f)。

.toString(16)因为我需要负值进行正确编码,所以简单对我不起作用。到目前为止,以下代码是我测试过的最快的1-2个字节的值(请注意,它symbols定义了要获取的输出符号的数量,即对于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;
}

它的执行速度比.toString(16)1-2个字节的数字要快,而对较大的数字(symbols> = 6)则要慢一些,但仍应胜过正确编码负值的方法。


5

如公认的答案所述,从十进制转换为十六进制的最简单方法是var hex = dec.toString(16)。但是,您可能希望添加字符串转换,因为它可以确保类似的字符串表示形式"12".toString(16)正常工作。

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

要逆转该过程,您还可以使用以下解决方案,因为它甚至更短。

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

在Google Chrome和Firefox中,速度似乎较慢,但在Opera中则明显更快。参见http://jsperf.com/hex-to-dec


5

如何在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

5
噢,我的……这是一种非常糟糕,可怕的方式,以更丑陋的编码风格完成。老实说:换行和缩进有什么问题?单字母变量?真?
VictorSchröder'16

1
修改了。这样可怕吗?而且风格更好吗?我原本以为,用字母拼出这样的“字面意义”的每一步都会更容易理解...有时我会很愚蠢
JonLikeSquirrel 2016年

4
抱歉,是的,仍然很糟糕。您的代码仍然使用许多低效的循环,并且污染了全局名称空间,还有其他问题。对于可以通过简单的函数调用完成的任务而言,这种方法本身就显得过于矫kill过正。如果您想改善JS中的编码风格,强烈建议您阅读w3.org/wiki/JavaScript_best_practicesgoogle.github.io/styleguide/javascriptguide.xml之类的材料。只是谷歌有关的主题。
VictorSchröder'16

1
我在Chrome中进行了速度测试,我的过大功能比.toString(16)快30%,而在Firefox中,我的功能比.toString(16)慢40%... Chrome证明我过多的循环更加有效而不是浏览器的本机.toString(16)函数,而Firefox证明了为什么更多的人更喜欢Chrome。还是倒退?有一天,Chrome甚至可能会更新为更快的.toString(16),这两种情况都使我不正确!无论哪种方式,我都不是完全错误的,而您也不是完全正确的。撇开我的自我,我确实至少可以理解您的观点的30%。;)
JonLikeSquirrel

2
您不必声明每个都包含单个字符的字符串数组。只需声明一个字符串。您可以像使用数组一样使用方括号从字符串中获取字符。
David Spector

3

总结一下;

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;
}

但是,如果您不需要在末尾将其转换回整数(即颜色),则只需确保值不为负就足够了。


2

我没有找到一个明确的答案,没有检查它是否是负数或正数,它使用二进制补码(包括负数)。为此,我展示了对一个字节的解决方案:

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

您可以对任何数字字节使用此指令,只需FF在各个位置添加即可。例如,要两个字节:

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

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

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

2

如果您希望转换为“完整” JavaScript或CSS表示形式,则可以使用以下方法:

  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

如果要转换大整数,即大于Number.MAX_SAFE_INTEGER的数字-9007199254740991,则可以使用以下代码

const hugeNumber = "9007199254740991873839" // Make sure its in String
const hexOfHugeNumber = BigInt(hugeNumber).toString(16);
console.log(hexOfHugeNumber)


1

这基于Prestaul和Tod的解决方案。但是,这是一个概括,说明了变量大小的变化(例如,从微控制器串行日志中解析带符号的值)。

function decimalToPaddedHexString(number, bitsize)
{ 
  let byteCount = Math.ceil(bitsize/8);
  let maxBinValue = Math.pow(2, bitsize)-1;

  /* In node.js this function fails for bitsize above 32bits */
  if (bitsize > 32)
    throw "number above maximum value";

  /* Conversion to unsigned form based on  */
  if (number < 0)
    number = maxBinValue + number + 1;

  return "0x"+(number >>> 0).toString(16).toUpperCase().padStart(byteCount*2, '0');
}

测试脚本:

for (let n = 0 ; n < 64 ; n++ ) { 
     let s=decimalToPaddedHexString(-1, n); 
     console.log(`decimalToPaddedHexString(-1,${(n+"").padStart(2)}) = ${s.padStart(10)} = ${("0b"+parseInt(s).toString(2)).padStart(34)}`);
   }

试验结果:

decimalToPaddedHexString(-1, 0) =        0x0 =                                0b0
decimalToPaddedHexString(-1, 1) =       0x01 =                                0b1
decimalToPaddedHexString(-1, 2) =       0x03 =                               0b11
decimalToPaddedHexString(-1, 3) =       0x07 =                              0b111
decimalToPaddedHexString(-1, 4) =       0x0F =                             0b1111
decimalToPaddedHexString(-1, 5) =       0x1F =                            0b11111
decimalToPaddedHexString(-1, 6) =       0x3F =                           0b111111
decimalToPaddedHexString(-1, 7) =       0x7F =                          0b1111111
decimalToPaddedHexString(-1, 8) =       0xFF =                         0b11111111
decimalToPaddedHexString(-1, 9) =     0x01FF =                        0b111111111
decimalToPaddedHexString(-1,10) =     0x03FF =                       0b1111111111
decimalToPaddedHexString(-1,11) =     0x07FF =                      0b11111111111
decimalToPaddedHexString(-1,12) =     0x0FFF =                     0b111111111111
decimalToPaddedHexString(-1,13) =     0x1FFF =                    0b1111111111111
decimalToPaddedHexString(-1,14) =     0x3FFF =                   0b11111111111111
decimalToPaddedHexString(-1,15) =     0x7FFF =                  0b111111111111111
decimalToPaddedHexString(-1,16) =     0xFFFF =                 0b1111111111111111
decimalToPaddedHexString(-1,17) =   0x01FFFF =                0b11111111111111111
decimalToPaddedHexString(-1,18) =   0x03FFFF =               0b111111111111111111
decimalToPaddedHexString(-1,19) =   0x07FFFF =              0b1111111111111111111
decimalToPaddedHexString(-1,20) =   0x0FFFFF =             0b11111111111111111111
decimalToPaddedHexString(-1,21) =   0x1FFFFF =            0b111111111111111111111
decimalToPaddedHexString(-1,22) =   0x3FFFFF =           0b1111111111111111111111
decimalToPaddedHexString(-1,23) =   0x7FFFFF =          0b11111111111111111111111
decimalToPaddedHexString(-1,24) =   0xFFFFFF =         0b111111111111111111111111
decimalToPaddedHexString(-1,25) = 0x01FFFFFF =        0b1111111111111111111111111
decimalToPaddedHexString(-1,26) = 0x03FFFFFF =       0b11111111111111111111111111
decimalToPaddedHexString(-1,27) = 0x07FFFFFF =      0b111111111111111111111111111
decimalToPaddedHexString(-1,28) = 0x0FFFFFFF =     0b1111111111111111111111111111
decimalToPaddedHexString(-1,29) = 0x1FFFFFFF =    0b11111111111111111111111111111
decimalToPaddedHexString(-1,30) = 0x3FFFFFFF =   0b111111111111111111111111111111
decimalToPaddedHexString(-1,31) = 0x7FFFFFFF =  0b1111111111111111111111111111111
decimalToPaddedHexString(-1,32) = 0xFFFFFFFF = 0b11111111111111111111111111111111
Thrown: 'number above maximum value'

注意:不太确定为什么失败超过32位大小


-3

这是我的解决方案:

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

问题说:“如何在JavaScript中将十进制转换为十六进制”。虽然该问题并未指定十六进制字符串应以0x前缀开头,但是任何编写代码的人都应该知道将0x添加到十六进制代码中以区分十六进制代码程序标识符其他数字(1234可以是十六进制,十进制或甚至八进制)。

因此,为了正确回答此问题,出于脚本编写的目的,您必须添加0x前缀。

Math.abs(N)函数将负数转换为正数,并且作为奖励,它看起来不像有人通过刨木机运行。

我想要的答案是具有一个字段宽度说明符,因此我们可以例如以在十六进制编辑应用程序中看到它们的方式显示8/16/32/64位值。那是实际的正确答案。


1
在一般编码实践中,任何以字母开头的字母数字序列都不是数字。例如:ABCDEF012345678是地球上几乎每种编码语言中的有效标识符。
Hypersoft Systems '18

1
哦,0x前缀对于javascript来说不是问题: Number('0xFF') === 255;对于所有想要反向操作的人来说。
Hypersoft Systems '18
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.