如何在JavaScript中将十进制值转换为十六进制等效值？
使用以下代码将数字转换为十六进制字符串：
hexString = yourNumber.toString(16);
并通过以下方式扭转过程：
yourNumber = parseInt(hexString, 16);
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
}
如果你想将一个数字转换为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;
}
对于任何有兴趣的人，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从十进制转换为十六进制以用作CSS作为color data type，您可能更愿意从小数中提取RGB值并使用rgb()。
例如（JSFiddle）：
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)。
这是一个精简的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'
如果数字是负数？
这是我的版本。
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);
}
您也可以查看以下JsFiddle example或Stack Overflow JavaScript示例代码。
'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 => 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时），但仍然应该胜过正确编码负值的方法。
如果需要处理位字段或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));正如公认的答案所述，从十进制转换为十六进制的最简单方法是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);
谷歌Chrome和Firefox似乎要慢一些，但Opera的速度要快得多。见http://jsperf.com/hex-to-dec。
如何在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
总而言之;
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
你可以在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)这是我的解决方案：
hex = function(number) {
return '0x' + Math.abs(number).toString(16);
}
问题是：“如何在JavaScript中将十进制转换为十六进制”。虽然，问题没有指定十六进制字符串应该以0x前缀开头，但任何编写代码的人都应该知道0x被添加到十六进制代码以区分十六进制代码与程序标识符和其他数字（1234可以是十六进制，十进制或甚至是八进制）。
因此，要正确回答此问题，为了编写脚本，必须添加0x前缀。
Math.abs（N）函数将负数转换为正数，作为奖励，它看起来并不像有人通过木材削片机运行它。
我想要的答案是，有一个字段宽度说明符，所以我们可以像在十六进制编辑应用程序中看到的那样显示8/16/32/64位值。那是实际的正确答案。
下面的代码将十进制值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 dec2hex(i) {
return (i+0x10000).toString(16).substr(-4).toUpperCase();
}
完成后，如果你想要负数的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位二进制补码。
没有循环：
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++){}
将一些好的想法结合起来用于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);
}
接受的答案没有考虑单个数字返回的十六进制代码。这很容易调整：
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”AS A NUMBER放入变量中 - 您将能够得到的只是“3”，因为小数部分只能通过重复乘以10（IE：10.0）来访问。或者换句话说 - 十六进制值0xF会导致浮点值在AND之前被转换为整数，从而删除句点后面的所有内容。而不是将值作为一个整体（即：3.14159265）并将浮点值与0xF值进行AND运算。
因此，在这种情况下，最好的做法是将3.14159265转换为字符串，然后只转换字符串。由于上述原因，它也可以很容易地转换负数，因为减号在值的前面只变为0x26。
所以我做的是确定变量包含一个数字 - 只需将其转换为字符串并转换字符串。这意味着对于服务器端的每个人，您将需要取消传入传入的字符串，然后确定传入的信息是数字。您只需在数字前面添加“＃”，然后在返回的字符串前面添加“A”即可轻松完成。请参阅toHex（）函数。
玩得开心！
经过一年多的思考，我认为“toHex”功能（我也有“fromHex”功能）确实需要进行改造。整个问题是“我怎样才能更有效地做到这一点？”我决定a / from十六进制函数不应该关心某些东西是否是一个小数部分，但同时它应该确保小数部分包含在字符串中。
那么问题就变成了，“你怎么知道你正在使用十六进制字符串？”。答案很简单。使用世界各地已经识别的标准预字符串信息。
换句话说 - 使用“0x”。所以现在我的toHex函数看看是否已经存在，如果是 - 它只返回发送给它的字符串。否则，它会转换字符串，数字等等。这是修改后的toHex功能：/////////////////////////////////////////// ////////////////////////////////// // toHex（）将ASCII字符串转换为十六进制。 ////////////////////////////////////////////////// /////////////////////////// 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) == "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。
<?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（）函数。