blocks|key|1768620|text|使用以下命令将数字转换为十六进制字符串：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1768621|hexString+=+yourNumber.toString(16);|code-block|syntax|javascript|1768622|并使用以下命令反转此过程：|1768623|yourNumber+=+parseInt(hexString,+16);|1768624|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Convert a number to a hexadecimal string with:
<pre><code>hexString = yourNumber.toString(16);
</code></pre>
And reverse the process with:
<pre><code>yourNumber = parseInt(hexString, 16);
</code></pre>

blocks|key|1768763|text|如果您需要处理位字段或32位颜色之类的内容，则需要处理有符号数字。JavaScript函数toString(16)将返回一个负的十六进制数，这通常不是您想要的。这个函数做了一些疯狂的加法，使它成为一个正数。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1768764|​|1768765|function+decimalToHexString(number)
{
++if+(number+<+0)
++{
++++number+=+0xFFFFFFFF+%2B+number+%2B+1;
++}

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

console.log(decimalToHexString(27));
console.log(decimalToHexString(48.6));|code-block|syntax|javascript|1768766|1768767|entityMap^0|19|C|0|0|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@$9|Q|A|R|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|S|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|T|8|@]|D|@]|E|$K|L]]|$1|M|3|G|5|6|7|U|8|@]|D|@]|E|$]]|$1|N|3|-4|5|6|7|V|8|@]|D|@]|E|$]]]|O|$]]

If you need to handle things like bit fields or 32-bit colors, then you need to deal with signed numbers. The JavaScript function <code>toString(16)</code> will return a negative hexadecimal number which is usually not what you want. This function does some crazy addition to make it a positive number.

<div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>function decimalToHexString(number)
{
 if (number &lt; 0)
 {
 number = 0xFFFFFFFF + number + 1;
 }

 return number.toString(16).toUpperCase();
}

console.log(decimalToHexString(27));
console.log(decimalToHexString(48.6));</code></pre>
</div>
</div>

blocks|key|1768658|text|下面的代码将把十进制值d转换为十六进制。它还允许您向十六进制结果添加填充。因此，默认情况下，0将变为00。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1768659|function+decimalToHex(d,+padding)+{
++++var+hex+=+Number(d).toString(16);
++++padding+=+typeof+(padding)+===+"undefined"+%7C%7C+padding+===+null+?+padding+=+2+:+padding;

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

++++return+hex;
}|code-block|syntax|javascript|1768660|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

The code below will convert the decimal value d to hexadecimal. It also allows you to add padding to the hexadecimal result. So 0 will become 00 by default.

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

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

 return hex;
}
</code></pre>

blocks|key|1553939|text|function+toHex(d)+{
++++return++("0"%2B(Number(d).toString(16))).slice(-2).toUpperCase()
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1553940|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>function toHex(d) {
 return ("0"+(Number(d).toString(16))).slice(-2).toUpperCase()
}
</code></pre>

blocks|key|1769199|text|为了完整性，如果需要负数的two's-complement十六进制表示，可以使用zero-fill-right+shift+>>>+operator。例如：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1769200|>+(-1).toString(16)
"-1"

>+((-2)>>>0).toString(16)
"fffffffe"|code-block|syntax|javascript|1769201|然而，有一个限制：JavaScript+bitwise+operators+treat+their+operands+as+a+sequence+of+32+bits，也就是说，你得到的是32位的二进制补码。|1769202|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Two%2527s_complement|1|https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators#%253E%253E%253E_%2528Zero-fill_right_shift%2529|2|https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators#Summary^0|1Q|3|D|G|0|14|Y|1|0|0|9|22|2|0^^$0|@$1|2|3|4|5|6|7|Y|8|@$9|Z|A|10|B|C]]|D|@$9|11|A|12|1|13]|$9|14|A|15|1|16]]|E|$]]|$1|F|3|G|5|H|7|17|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|18|8|@]|D|@$9|19|A|1A|1|1B]]|E|$]]|$1|M|3|-4|5|6|7|1C|8|@]|D|@]|E|$]]]|N|$O|$5|P|Q|R|E|$S|T]]|U|$5|P|Q|R|E|$S|V]]|W|$5|P|Q|R|E|$S|X]]]]

For completeness, if you want the <a href="http://en.wikipedia.org/wiki/Two%27s_complement" rel="noreferrer" title="Two&#39;s complement [Wikipedia]">two's-complement</a> hexadecimal representation of a negative number, you can use the <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators#%3E%3E%3E_%28Zero-fill_right_shift%29" rel="noreferrer" title="Zero-fill right shift [MDN]">zero-fill-right shift <code>&gt;&gt;&gt;</code> operator</a>. For instance:



<pre><code>&gt; (-1).toString(16)
"-1"

&gt; ((-2)&gt;&gt;&gt;0).toString(16)
"fffffffe"
</code></pre>

There is however one limitation: <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators#Summary" rel="noreferrer" title="Bitwise Operators [MDN]">JavaScript bitwise operators treat their operands as a sequence of 32 bits</a>, that is, you get the 32-bits two's complement.

blocks|key|1553817|text|使用填充：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1553818|function+dec2hex(i)+{
+++return+(i%2B0x10000).toString(16).substr(-4).toUpperCase();
}|code-block|syntax|javascript|1553819|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

With padding:

<pre><code>function dec2hex(i) {
 return (i+0x10000).toString(16).substr(-4).toUpperCase();
}
</code></pre>

blocks|key|1553784|text|在没有循环的情况下：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1553785|function+decimalToHex(d)+{
++var+hex+=+Number(d).toString(16);
++hex+=+"000000".substr(0,+6+-+hex.length)+%2B+hex;
++return+hex;
}

//+Or+"#000000".substr(0,+7+-+hex.length)+%2B+hex;
//+Or+whatever
//+*Thanks+to+MSDN|code-block|syntax|javascript|1553786|同样，不使用必须评估的循环测试不是更好吗？|1553787|例如，而不是：|1553788|for+(var+i+=+0;+i+<+hex.length;+i%2B%2B){}|1553789|有|1553790|for+(var+i+=+0,+var+j+=+hex.length;+i+<+j;+i%2B%2B){}|1553791|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|V|8|@]|9|@]|A|$]]|$1|K|3|L|5|D|7|W|8|@]|9|@]|A|$E|F]]|$1|M|3|N|5|6|7|X|8|@]|9|@]|A|$]]|$1|O|3|P|5|D|7|Y|8|@]|9|@]|A|$E|F]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

Without the loop:

<pre><code>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
</code></pre>

Also isn't it better not to use loop tests that have to be evaluated?

For example, instead of:

<pre><code>for (var i = 0; i &lt; hex.length; i++){}
</code></pre>

have

<pre><code>for (var i = 0, var j = hex.length; i &lt; j; i++){}
</code></pre>

blocks|key|1769022|text|将这些好的想法组合成一个RGB-value-to-hexadecimal函数(在其他地方为HTML/CSS添加#+)：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1769023|function+rgb2hex(r,g,b)+{
++++if+(g+!==+undefined)
++++++++return+Number(0x1000000+%2B+r*0x10000+%2B+g*0x100+%2B+b).toString(16).substring(1);
++++else
++++++++return+Number(0x1000000+%2B+r[0]*0x10000+%2B+r[1]*0x100+%2B+r[2]).toString(16).substring(1);
}|code-block|syntax|javascript|1769024|entityMap^0|1J|1|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

Combining some of these good ideas for an RGB-value-to-hexadecimal function (add the <code>#</code> elsewhere for HTML/CSS):

<pre><code>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);
}
</code></pre>

blocks|key|1553677|text|var+number+=+3200;
var+hexString+=+number.toString(16);|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1553678|16是基数，十六进制数中有16个值:-)|unstyled|1553679|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|J|8|@]|9|@]|A|$]]|$1|G|3|-4|5|F|7|K|8|@]|9|@]|A|$]]]|H|$]]

<pre><code>var number = 3200;
var hexString = number.toString(16);
</code></pre>

The 16 is the radix and there are 16 values in a hexadecimal number :-)

blocks|key|1553846|text|约束/填充到一定数量的字符：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1553847|function+decimalToHex(decimal,+chars)+{
++++return+(decimal+%2B+Math.pow(16,+chars)).toString(16).slice(-chars).toUpperCase();
}|code-block|syntax|javascript|1553848|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Constrained/padded to a set number of characters:

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

blocks|key|1553735|text|function+dec2hex(i)
{
++var+result+=+"0000";
++if++++++(i+>=+0++++&&+i+<=+15)++++{+result+=+"000"+%2B+i.toString(16);+}
++else+if+(i+>=+16+++&&+i+<=+255)+++{+result+=+"00"++%2B+i.toString(16);+}
++else+if+(i+>=+256++&&+i+<=+4095)++{+result+=+"0"+++%2B+i.toString(16);+}
++else+if+(i+>=+4096+&&+i+<=+65535)+{+result+=+++++++++i.toString(16);+}
++return+result
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1553736|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>function dec2hex(i)
{
 var result = "0000";
 if (i &gt;= 0 &amp;&amp; i &lt;= 15) { result = "000" + i.toString(16); }
 else if (i &gt;= 16 &amp;&amp; i &lt;= 255) { result = "00" + i.toString(16); }
 else if (i &gt;= 256 &amp;&amp; i &lt;= 4095) { result = "0" + i.toString(16); }
 else if (i &gt;= 4096 &amp;&amp; i &lt;= 65535) { result = i.toString(16); }
 return result
}
</code></pre>

blocks|key|1553887|text|如果您想将一个数字转换为RGBA颜色值的十六进制表示形式，我发现这是以下几个技巧中最有用的组合：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1553888|function+toHexString(n)+{
++++if(n+<+0)+{
++++++++n+=+0xFFFFFFFF+%2B+n+%2B+1;
++++}
++++return+"0x"+%2B+("00000000"+%2B+n.toString(16).toUpperCase()).substr(-8);
}|code-block|syntax|javascript|1553889|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

If you want to convert a number to a hexadecimal representation of an RGBA color value, I've found this to be the most useful combination of several tips from here:

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

blocks|key|1553932|text|如果这个数字是负数呢？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1553933|这是我的版本。|1553934|function+hexdec+(hex_string)+{
++++hex_string=((hex_string.charAt(1)!='X'+&&+hex_string.charAt(1)!='x')?hex_string='0X'%2Bhex_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);
}|code-block|syntax|javascript|1553935|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

And if the number is negative?

Here is my version.

<pre><code>function hexdec (hex_string) {
 hex_string=((hex_string.charAt(1)!='X' &amp;&amp; hex_string.charAt(1)!='x')?hex_string='0X'+hex_string : hex_string);
 hex_string=(hex_string.charAt(2)&lt;8 ? hex_string =hex_string-0x00000000 : hex_string=hex_string-0xFFFFFFFF-1);
 return parseInt(hex_string, 10);
}
</code></pre>

blocks|key|1769095|text|我在一个相当大的循环中转换成十六进制字符串，所以我尝试了几种技术，以便找到最快的一种。我的要求是得到一个固定长度的字符串，并对负值进行正确编码(-1+=>+ff.f)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1769096|简单的.toString(16)对我不起作用，因为我需要对负值进行正确编码。下面的代码是迄今为止我测试过的最快的1-2字节值(请注意，symbols定义了您想要获取的输出符号的数量，即对于4字节的整数，它应该等于8)：|offset|length|style|CODE|1769097|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]+%2B+result;
++++++++num+>>=+4;
++++}
++++return+result;
}|code-block|syntax|javascript|1769098|它在1-2字节数上比.toString(16)快，在更大的数字上慢(当symbols+>=+6时)，但仍然应该比正确编码负值的方法更好。|1769099|entityMap^0|0|3|D|1V|7|0|0|A|D|Z|7|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@$D|S|E|T|F|G]|$D|U|E|V|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|W|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|X|8|@$D|Y|E|Z|F|G]|$D|10|E|11|F|G]]|9|@]|A|$]]|$1|O|3|-4|5|6|7|12|8|@]|9|@]|A|$]]]|P|$]]

I'm doing conversion to hex string in a pretty large loop, so I tried several techniques in order to find the fastest one. My requirements were to have a fixed-length string as a result, and encode negative values properly (-1 => ff..f).

Simple <code>.toString(16)</code> didn't work for me since I needed negative values to be properly encoded. The following code is the quickest I've tested so far on 1-2 byte values (note that <code>symbols</code> defines the number of output symbols you want to get, that is for 4-byte integer it should be equal to 8):

<pre><code>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 &amp; 0xF] + result;
 num &gt;&gt;= 4;
 }
 return result;
}
</code></pre>

It performs faster than <code>.toString(16)</code> on 1-2 byte numbers and slower on larger numbers (when <code>symbols</code> >= 6), but still should outperform methods that encode negative values properly.

blocks|key|1769149|text|正如公认的答案所述，将十进制转换为十六进制的最简单方法是var+hex+=+dec.toString(16)。但是，您可能更喜欢添加字符串转换，因为它可以确保像"12".toString(16)这样的字符串表示能够正常工作。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1769150|//+Avoids+a+hard-to-track-down+bug+by+returning+`c`+instead+of+`12`
(%2B"12").toString(16);|code-block|syntax|javascript|1769151|为了逆转这个过程，你也可以使用下面的解决方案，因为它更短。|1769152|var+dec+=+%2B("0x"+%2B+hex);|1769153|在Google+Chrome和Firefox中，它似乎更慢，但在Opera中，它的速度要快得多。参见http://jsperf.com/hex-to-dec。|1769154|entityMap|0|LINK|mutability|MUTABLE|url|http://jsperf.com/hex-to-dec^0|S|Q|28|H|0|0|0|0|1E|S|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@$9|Z|A|10|B|C]|$9|11|A|12|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|13|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|14|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|15|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|16|8|@]|D|@$9|17|A|18|1|19]]|E|$]]|$1|Q|3|-4|5|6|7|1A|8|@]|D|@]|E|$]]]|R|$S|$5|T|U|V|E|$W|X]]]]

As the accepted answer states, the easiest way to convert from decimal to hexadecimal is <code>var hex = dec.toString(16)</code>. However, you may prefer to add a string conversion, as it ensures that string representations like <code>"12".toString(16)</code> work correctly.

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

To reverse the process you may also use the solution below, as it is even shorter.

<pre><code>var dec = +("0x" + hex);
</code></pre>

It seems to be slower in Google Chrome and Firefox, but is significantly faster in Opera. See <a href="http://jsperf.com/hex-to-dec" rel="nofollow noreferrer">http://jsperf.com/hex-to-dec</a>.

blocks|key|1554342|text|您可以在ECMAScript 6中执行类似的操作|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1554343|const+toHex+=+num+=>+(num).toString(16).toUpperCase();|code-block|syntax|javascript|1554344|entityMap|0|LINK|mutability|MUTABLE|url|https://en.wikipedia.org/wiki/ECMAScript#6th_Edition_-_ECMAScript_2015^0|4|C|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

You can do something like this in <a href="https://en.wikipedia.org/wiki/ECMAScript#6th_Edition_-_ECMAScript_2015" rel="nofollow noreferrer">ECMAScript&nbsp;6</a>:

<pre><code>const toHex = num =&gt; (num).toString(16).toUpperCase();
</code></pre>

blocks|key|1554393|text|如果您正在寻找转换大整数，即大于Number.MAX_SAFE_INTEGER+--+9007199254740991的数字，那么可以使用以下代码|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1554394|​|1554395|const+hugeNumber+=+"9007199254740991873839"+//+Make+sure+its+in+String
const+hexOfHugeNumber+=+BigInt(hugeNumber).toString(16);
console.log(hexOfHugeNumber)|code-block|syntax|javascript|1554396|1554397|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|N|8|@]|9|@]|A|$G|H]]|$1|I|3|C|5|6|7|O|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|P|8|@]|9|@]|A|$]]]|K|$]]

If you are looking for converting Large integers i.e. Numbers greater than Number.MAX_SAFE_INTEGER -- 9007199254740991, then you can use the following code

<div class="snippet" data-lang="js" data-hide="false" data-console="true" data-babel="false">
<div class="snippet-code">
<pre class="snippet-code-js lang-js prettyprint-override"><code>const hugeNumber = "9007199254740991873839" // Make sure its in String
const hexOfHugeNumber = BigInt(hugeNumber).toString(16);
console.log(hexOfHugeNumber)</code></pre>
</div>
</div>

blocks|key|1769256|text|总结一下；|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1769257|function+toHex(i,+pad)+{

++if+(typeof(pad)+===+'undefined'+%7C%7C+pad+===+null)+{
++++pad+=+2;
++}+

++var+strToParse+=+i.toString(16);

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

++var+finalVal+=++parseInt(strToParse,+16);

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

++return+finalVal;
}|code-block|syntax|javascript|1769258|但是，如果你不需要在最后将它转换回一个整数(例如，对于颜色)，那么只需确保这些值不是负值就足够了。|1769259|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

To sum it all up;

<pre><code>function toHex(i, pad) {

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

 var strToParse = i.toString(16);

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

 var finalVal = parseInt(strToParse, 16);

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

 return finalVal;
}
</code></pre>

However, if you don't need to convert it back to an integer at the end (i.e. for colors), then just making sure the values aren't negative should suffice.

blocks|key|1554262|text|我还没有找到一个明确的答案，没有检查它是负的还是正的，它使用了2的补码(包括负数)。为此，我将我的解决方案显示为一个字节：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1554263|((0xFF+%2B+number+%2B1)+&+0x0FF).toString(16);|code-block|syntax|javascript|1554264|你可以对任何字节数使用该指令，只需在相应的位置添加FF即可。例如，设置为两个字节：|offset|length|style|CODE|1554265|((0xFFFF+%2B+number+%2B1)+&+0x0FFFF).toString(16);|1554266|如果要将数组整数转换为字符串十六进制：|1554267|s+=+"";
for(var+i+=+0;+i+<+arrayNumber.length;+%2B%2Bi)+{
++++s+%2B=+((0xFF+%2B+arrayNumber[i]+%2B1)+&+0x0FF).toString(16);
}|1554268|entityMap^0|0|0|P|2|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|W|8|@$I|X|J|Y|K|L]]|9|@]|A|$]]|$1|M|3|N|5|D|7|Z|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|10|8|@]|9|@]|A|$]]|$1|Q|3|R|5|D|7|11|8|@]|9|@]|A|$E|F]]|$1|S|3|-4|5|6|7|12|8|@]|9|@]|A|$]]]|T|$]]

I haven't found a clear answer, without checks if it is negative or positive, that uses two's complement (negative numbers included). For that, I show my solution to one byte:

<pre><code>((0xFF + number +1) &amp; 0x0FF).toString(16);
</code></pre>

You can use this instruction to any number bytes, only you add <code>FF</code> in respective places. For example, to two bytes:

<pre><code>((0xFFFF + number +1) &amp; 0x0FFFF).toString(16);
</code></pre>

If you want cast an array integer to string hexadecimal:

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

blocks|key|1769372|text|如果你想转换成“完整的”JavaScript或CSS表示，你可以使用类似这样的东西：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1769373|++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'%2Br;+}
++++if+(g.length==1)+{+g+=+'0'%2Bg;+}
++++if+(b.length==1)+{+b+=+'0'%2Bb;+}
++++return+'0x'%2Br%2Bg%2Bb;+++++++++++++++++//+('#'+instead+of'0x'+for+CSS)
++};

++var+dec+=+5974678;
++console.log(+numToHex(dec)+);++++++++//+0x5b2a96|code-block|syntax|javascript|1769374|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

In case you're looking to convert to a 'full' JavaScript or CSS representation, you can use something like:

<pre><code> numToHex = function(num) {
 var r=((0xff0000&amp;num)&gt;&gt;16).toString(16),
 g=((0x00ff00&amp;num)&gt;&gt;8).toString(16),
 b=(0x0000ff&amp;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
</code></pre>

blocks|key|1554456|text|这是基于Prestaul和Tod的解决方案。然而，这是一种泛化，说明了变量的不同大小(例如，从微控制器串行日志解析有符号值)。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1554457|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+%2B+number+%2B+1;

++return+"0x"%2B(number+>>>+0).toString(16).toUpperCase().padStart(byteCount*2,+'0');
}|code-block|syntax|javascript|1554458|测试脚本：|1554459|for+(let+n+=+0+;+n+<+64+;+n%2B%2B+)+{+
+++++let+s=decimalToPaddedHexString(-1,+n);+
+++++console.log(`decimalToPaddedHexString(-1,${(n%2B"").padStart(2)})+=+${s.padStart(10)}+=+${("0b"%2BparseInt(s).toString(2)).padStart(34)}`);
+++}|1554460|测试结果：|1554461|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'|1554462|注意:不太确定32位大小以上失败的原因|1554463|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|W|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|Y|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

This is based on Prestaul and Tod's solutions. However, this is a generalisation that accounts for varying size of a variable (e.g. Parsing signed value from a microcontroller serial log). 

<pre><code>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 &gt; 32)
 throw "number above maximum value";

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

 return "0x"+(number &gt;&gt;&gt; 0).toString(16).toUpperCase().padStart(byteCount*2, '0');
}
</code></pre>

Test script:

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

Test results:

<pre><code>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'
</code></pre>

Note: Not too sure why it fails above 32 bitsize

blocks|key|1554532|text|将十六进制颜色数字转换为十六进制颜色字符串：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1554533|使用toString和ES6+padStart将十六进制颜色数字转换为十六进制颜色字符串的简单解决方案。|offset|length|style|CODE|1554534|const+string+=+`#${color.toString(16).padStart(6,+'0')}`;|code-block|syntax|javascript|1554535|例如：|1554536|0x000000将成为#000000|1554537|0xFFFFFF将成为#FFFFFF|1554538|Check+this+example+in+a+fiddle+here|1554539|entityMap|0|LINK|mutability|MUTABLE|url|https://jsfiddle.net/wilt/zg1vcbu3/^0|0|2|8|F|8|0|0|0|0|8|B|7|0|0|8|B|7|0|0|Z|0|0^^$0|@$1|2|3|4|5|6|7|12|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|13|8|@$D|14|E|15|F|G]|$D|16|E|17|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|18|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|19|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|1A|8|@$D|1B|E|1C|F|G]|$D|1D|E|1E|F|G]]|9|@]|A|$]]|$1|Q|3|R|5|6|7|1F|8|@$D|1G|E|1H|F|G]|$D|1I|E|1J|F|G]]|9|@]|A|$]]|$1|S|3|T|5|6|7|1K|8|@]|9|@$D|1L|E|1M|1|1N]]|A|$]]|$1|U|3|-4|5|6|7|1O|8|@]|9|@]|A|$]]]|V|$W|$5|X|Y|Z|A|$10|11]]]]

<h2>Converting hex color numbers to hex color strings:</h2>
A simple solution with <code>toString</code> and ES6 <code>padStart</code> for converting hex color numbers to hex color strings.
<pre><code>const string = `#${color.toString(16).padStart(6, '0')}`;
</code></pre>
For example:
<code>0x000000</code> will become <code>#000000</code> 
<code>0xFFFFFF</code> will become <code>#FFFFFF</code>
<a href="https://jsfiddle.net/wilt/zg1vcbu3/" rel="nofollow noreferrer">Check this example in a fiddle here</a>

How do you convert decimal values to their hexadecimal equivalent in JavaScript?

How to convert decimal to hexadecimal in JavaScript

微控制器

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

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

回答 22

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

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

回答 22

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

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