在 JavaScript 中如何将十进制值转换为相应的十六进制值?

有帮助吗?

解决方案

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

hexString = yourNumber.toString(16);

并通过以下方式反转该过程:

yourNumber = parseInt(hexString, 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));

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

为了完成,如果您想要 二进制补码 负数的十六进制表示,您可以使用 零填充右移 >>> 操作员. 。例如:

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

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

但有一个限制: JavaScript 按位运算符将其操作数视为 32 位序列, ,即得到 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+ 个有用的 JavaScript 正则表达式函数可提高您的 Web 应用程序效率.

更新:经过多次测试后,我发现了一个错误(正则表达式中的双引号),所以我修复了这个错误。然而!经过相当多的测试并阅读了 almaz 的帖子 - 我意识到我无法让负数起作用。

此外 - 我对此进行了一些阅读,因为无论如何,所有 JavaScript 数字都存储为 64 位字 - 我尝试修改 numHex 代码以获取 64 位字。但事实证明你不能那样做。如果您将“3.14159265”作为数字放入变量中 - 您将能够得到的只是“3”,因为小数部分只能通过将数字重复乘以十(即:10.0)来访问。或者换句话说—— 十六进制 0xF 的值会导致 浮点 值被转化为 整数 在它之前进行 AND 运算,删除句号后面的所有内容。而不是将值视为一个整体(即:3.14159265) 并对 浮点 值与 0xF 值相对应。

因此,在这种情况下,最好的办法是将 3.14159265 转换为 细绳 然后只转换字符串。由于上述原因,它也使得负数转换变得很容易,因为减号正好变成值前面的 0x26。

所以我所做的就是确定变量包含一个数字 - 只需将其转换为字符串并转换该字符串。这对每个人来说意味着在服务器端您需要对传入的字符串进行十六进制处理,然后确定传入的信息是数字。只需在数字前面添加“#”,在返回的字符串前面添加“A”,即可轻松完成此操作。请参阅 toHex() 函数。

玩得开心!

经过一年的大量思考,我决定“toHex”函数(我也有一个“fromHex”函数)确实需要修改。整个问题是“我该如何更有效地做到这一点?”我认为a dout/from来自十六进制功能不应该在乎某物是否是分数部分,但同时应确保将分数零件包含在字符串中。

那么问题就变成了“你怎么知道你正在使用十六进制字符串?”。答案很简单。使用世界范围内已经认可的标准预串信息。

换句话说 - 使用“0x”。所以现在我的 toHex 函数会查看它是否已经存在,如果存在 - 它只返回发送给它的字符串。否则,它会转换字符串、数字等。这是修改后的 toHex 函数://////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////tohex()。将 ASCII 字符串转换为十六进制。//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////// tohex(s){if(s.substr(0,2).tolowercase()==“ 0x ”){返回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) 个字符。但是您还需要确保该字符串不能被四整除。如果是 - 那么它是一个标准的十六进制字符串。(请记住该字符串前面有“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() 函数。

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

对于任何有兴趣的人来说, 这是一个 JSFiddle 比较了这个问题的大多数答案.

这是我最终采用的方法:

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

另外,请记住,如果您希望将十进制转换为十六进制以在 CSS 中用作 颜色数据类型, ,您可能更喜欢从小数中提取 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 示例 或 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;
}

它的执行速度比 .toString(16) 在 1-2 个字节的数字上,在较大的数字上速度较慢(当 symbols >= 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);

它在 Google 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 位值。这就是实际的、正确的答案。

许可以下: CC-BY-SA归因
不隶属于 StackOverflow
scroll top