如何在 JavaScript 中将十进制值转换为对应的十六进制？
【问题讨论】：
标签： javascript hex number-formatting base
将数字转换为十六进制字符串：
hexString = yourNumber.toString(16);
然后用以下方法逆转这个过程：
yourNumber = parseInt(hexString, 16);
【讨论】：
yourNumber 是一个变量。如果您想使用数字文字，则必须执行(45).toString(16) 之类的操作，但如果您要对数字进行硬编码，请自己将其写为十六进制字符串...(45).toString(16) 将始终等于@ 987654326@，所以不要浪费 CPU 周期来解决这个问题。
42..toString(16)
42 与42.0 相同。但是省略零并写42. 是合法的。所以如果你写42.toString(16)，句号不会被看作是你试图调用一个函数，而是作为小数点。因此，要实际调用一个函数，您必须在小数点后添加一个额外的句点
如果您需要处理位域或 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));【讨论】：
number = 0x100000000 + number;
>>> 运算符将数字转换为无符号表示，例如((-3253) >>> 0).toString(16) 返回"fffff34b"。
+1 是一个有用的补充，但如果您将数字转换为不同的符号，则所有数字“通常”已经是正数，否则您想要负数结果。
下面的代码会将十进制值 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 toHex(d) {
return ("0"+(Number(d).toString(16))).slice(-2).toUpperCase()
}
【讨论】：
function hexRep(number, width) { return (number+Math.pow(16, precision)).toString(16).slice(-width); }
const hex = d => Number(d).toString(16).padStart(2, '0') ?
为了完整起见，如果您想要 two's-complement 十六进制表示负数，您可以使用 zero-fill-right shift >>> operator。例如：
> (-1).toString(16)
"-1"
> ((-2)>>>0).toString(16)
"fffffffe"
但是有一个限制：JavaScript bitwise operators treat their operands as a sequence of 32 bits，也就是说，您可以得到 32 位二进制补码。
【讨论】：
C# number to hexadecimal 产生的结果与Javascript number to hexadecimal 不同。看起来Javascript有负数的问题。这个答案似乎是解决问题的方法。
((-2)>>>0).toString(16).substring(2)
带内边距：
function dec2hex(i) {
return (i+0x10000).toString(16).substr(-4).toUpperCase();
}
【讨论】：
没有循环：
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++){}
【讨论】：
接受的答案未考虑返回的单个数字十六进制代码。这很容易通过以下方式调整：
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+ Useful JavaScript Regular Expression Functions to improve your web applications efficiency。
更新：在多次测试这个东西后，我发现了一个错误（RegExp 中的双引号），所以我修复了它。然而！经过大量测试并阅读了 almaz 的帖子后，我意识到我无法让负数起作用。
进一步 - 我对此进行了一些阅读，因为无论如何所有 JavaScript 数字都存储为 64 位字 - 我尝试修改 numHex 代码以获取 64 位字。但事实证明你不能那样做。如果您将“3.14159265”作为数字放入变量中 - 您将能够得到的只是“3”，因为小数部分只能通过重复将数字乘以十（IE：10.0）来访问。或者换一种说法 - 0xF 的 hexadecimal 值导致 floating point 值在它被 ANDed 之前被转换为一个 integer期间的一切。而不是将值作为一个整体（即：3.14159265）并将 浮点 值与 0xF 值进行与运算。
因此，在这种情况下，最好的做法是将 3.14159265 转换为 字符串，然后再转换字符串。由于上述原因，负数的转换也很容易，因为减号正好变成了值前面的 0x26。
所以我所做的是确定变量包含一个数字 - 只需将其转换为字符串并转换字符串。这对每个人来说意味着，在服务器端，您需要对传入的字符串进行 unhex，然后确定传入的信息是数字的。您只需在数字前面添加“#”，在返回的字符串前面添加“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"）。没有进一步调查。
substr & toLowerCase...所以typeof 需要早点出现，或者，如果你期望@ 987654335@ 在那里抛出一个非字符串，你应该完全删除typeof 检查。有道理？也就是说，如果我在这里使用代码而不进行编辑，并调用toHex(0x1f635)，我会得到Uncaught TypeError: s.substr is not a function。如果我更早地移动字符串，你是对的，数字首先转换为十进制，也许，事情就横向发展了。这当然意味着如果 s 不是字符串，你就不能在这里进行简单的转换。
将其中一些好的想法组合成一个 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);
}
【讨论】：
任何有兴趣的人，here's a JSFiddle comparing most of the answers given to this question。
这是我最终采用的方法：
function decToHex(dec) {
return (dec + Math.pow(16, 6)).toString(16).substr(-6)
}
另外，请记住，如果您希望将十进制转换为十六进制以便在 CSS 中用作 color data type，您可能更愿意从十进制中提取 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-element 的CSS color 属性设置为rgb(64, 62, 154)。
【讨论】：
var number = 3200;
var hexString = number.toString(16);
16 是基数，一个十六进制数有 16 个值 :-)
【讨论】：
限制/填充到一定数量的字符：
function decimalToHex(decimal, chars) {
return (decimal + Math.pow(16, chars)).toString(16).slice(-chars).toUpperCase();
}
【讨论】：
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
}
【讨论】：
color: rgb(r,g,b) 来回避整个问题，其中 r g 和 b 是十进制数。
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 }
如果您想将数字转换为 RGBA 颜色值的十六进制表示，我发现这是以下几个技巧的最有用组合：
function toHexString(n) {
if(n < 0) {
n = 0xFFFFFFFF + n + 1;
}
return "0x" + ("00000000" + n.toString(16).toUpperCase()).substr(-8);
}
【讨论】：
AFAIK comment 57807 是错误的，应该是这样的： 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;
}
【讨论】：
如果这个数字是负数呢？
这是我的版本。
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);
}
【讨论】：
正如接受的答案所述，从十进制转换为十六进制的最简单方法是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。
【讨论】：
我正在一个相当大的循环中转换为十六进制字符串，因此我尝试了几种技术以找到最快的一种。我的要求是得到一个固定长度的字符串，并正确编码负值（-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;
}
它在 1-2 字节数字上的执行速度比 .toString(16) 快，而在较大数字上的执行速度较慢（当 symbols >= 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
【讨论】：
你可以在ECMAScript 6做这样的事情：
const toHex = num => (num).toString(16).toUpperCase();
【讨论】：
如果您正在寻找转换大整数，即大于 Number.MAX_SAFE_INTEGER -- 9007199254740991 的数字，那么您可以使用以下代码
const hugeNumber = "9007199254740991873839" // Make sure its in String
const hexOfHugeNumber = BigInt(hugeNumber).toString(16);
console.log(hexOfHugeNumber)【讨论】：
总结一下；
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;
}
但是，如果您不需要在最后将其转换回整数（即颜色），那么只需确保值不是负数就足够了。
【讨论】：
我还没有找到一个明确的答案，没有检查它是负数还是正数，它使用二进制补码（包括负数）。为此，我将我的解决方案展示为一个字节：
((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);
}
【讨论】：
如果您希望转换为“完整”的 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
【讨论】：
rgb(255, 255, 255) // 返回 FFFFFF
rgb(255, 255, 300) // 返回 FFFFFF
rgb(0,0,0) // 返回 000000
rgb(148, 0, 211) // 返回 9400D3
function rgb(...values){
return values.reduce((acc, cur) => {
let val = cur >= 255 ? 'ff' : cur <= 0 ? '00' : Number(cur).toString(16);
return acc + (val.length === 1 ? '0'+val : val);
}, '').toUpperCase();
}
【讨论】：
这是基于 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 位会失败
【讨论】：
此解决方案采用输入十进制字符串，并返回十六进制字符串。支持小数部分。算法
s)、整数部分 (i) 和小数部分 (f) 例如 -123.75 我们有 s=true、i=123、f=75
i='0'停止m=i%16（任意精度）m 转换为十六进制数字并放入结果字符串i=i/16（任意精度）n
k=f*16（任意精度）k 与n 数字分开并放入f，将其余数字与左部分分开并放入d
d 转换为十六进制并添加到结果中。// @param decStr - string with non-negative integer
// @param divisor - positive integer
function dec2HexArbitrary(decStr, fracDigits=0) {
// Helper: divide arbitrary precision number by js number
// @param decStr - string with non-negative integer
// @param divisor - positive integer
function arbDivision(decStr, divisor)
{
// algorithm https://www.geeksforgeeks.org/divide-large-number-represented-string/
let ans='';
let idx = 0;
let temp = +decStr[idx];
while (temp < divisor) temp = temp * 10 + +decStr[++idx];
while (decStr.length > idx) {
ans += (temp / divisor)|0 ;
temp = (temp % divisor) * 10 + +decStr[++idx];
}
if (ans.length == 0) return "0";
return ans;
}
// Helper: calc module of arbitrary precision number
// @param decStr - string with non-negative integer
// @param mod - positive integer
function arbMod(decStr, mod) {
// algorithm https://www.geeksforgeeks.org/how-to-compute-mod-of-a-big-number/
let res = 0;
for (let i = 0; i < decStr.length; i++)
res = (res * 10 + +decStr[i]) % mod;
return res;
}
// Helper: multiply arbitrary precision integer by js number
// @param decStr - string with non-negative integer
// @param mult - positive integer
function arbMultiply(decStr, mult) {
let r='';
let m=0;
for (let i = decStr.length-1; i >=0 ; i--) {
let n = m+mult*(+decStr[i]);
r= (i ? n%10 : n) + r
m= n/10|0;
}
return r;
}
// dec2hex algorithm starts here
let h= '0123456789abcdef'; // hex 'alphabet'
let m= decStr.match(/-?(.*?)\.(.*)?/) || decStr.match(/-?(.*)/); // separate sign,integer,ractional
let i= m[1].replace(/^0+/,'').replace(/^$/,'0'); // integer part (without sign and leading zeros)
let f= (m[2]||'0').replace(/0+$/,'').replace(/^$/,'0'); // fractional part (without last zeros)
let s= decStr[0]=='-'; // sign
let r=''; // result
if(i=='0') r='0';
while(i!='0') { // integer part
r=h[arbMod(i,16)]+r;
i=arbDivision(i,16);
}
if(fracDigits) r+=".";
let n = f.length;
for(let j=0; j<fracDigits; j++) { // frac part
let k= arbMultiply(f,16);
f = k.slice(-n);
let d= k.slice(0,k.length-n);
r+= d.length ? h[+d] : '0';
}
return (s?'-':'')+r;
}
// -----------
// TESTS
// -----------
let tests = [
["0",2],
["000",2],
["123",0],
["-123",0],
["00.000",2],
["255.75",5],
["-255.75",5],
["127.999",32],
];
console.log('Input Standard Abitrary');
tests.forEach(t=> {
let nonArb = (+t[0]).toString(16).padEnd(17,' ');
let arb = dec2HexArbitrary(t[0],t[1]);
console.log(t[0].padEnd(10,' '), nonArb, arb);
});
// Long Example (40 digits after dot)
let example = "123456789012345678901234567890.09876543210987654321"
console.log(`\nLong Example:`);
console.log('dec:',example);
console.log('hex: ',dec2HexArbitrary(example,40));【讨论】：
这是我的解决方案：
hex = function(number) {
return '0x' + Math.abs(number).toString(16);
}
问题是：“如何在 JavaScript 中将十进制转换为十六进制”。虽然问题没有指定十六进制字符串应以 0x 前缀开头，但任何编写代码的人都应该知道 0x 被添加到十六进制代码以区分 十六进制代码 和 程序标识符 em> 和其他数字（1234 可以是十六进制、十进制甚至八进制）。
因此，要正确回答这个问题，为了编写脚本，必须添加 0x 前缀。
Math.abs(N) 函数将负数转换为正数，而且作为奖励，它看起来不像是有人通过木材削片机运行它。
我想要的答案应该有一个字段宽度说明符，因此我们可以例如显示 8/16/32/64 位值，就像您在十六进制编辑应用程序中看到它们一样。那是实际的正确答案。
【讨论】：
Number('0xFF') === 255; 对于所有想要反向操作的人。