Cách chuyển đổi thập phân thành thập lục phân trong JavaScript

Làm cách nào để bạn chuyển đổi giá trị thập phân thành tương đương thập lục phân của chúng trong JavaScript?

Chuyển đổi một số thành một chuỗi thập lục phân với:

hexString = yourNumber.toString(16);

Và đảo ngược quá trình với:

yourNumber = parseInt(hexString, 16);

Nếu bạn cần xử lý những thứ như trường bit hoặc màu 32 bit, thì bạn cần xử lý các số đã ký. Hàm JavaScript toString(16)sẽ trả về số thập lục phân âm thường không phải là số bạn muốn. Hàm này thực hiện một số bổ sung điên để biến nó thành một số dương.

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

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

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

Mã dưới đây sẽ chuyển đổi giá trị thập phân d thành thập lục phân. Nó cũng cho phép bạn thêm phần đệm vào kết quả thập lục phân. Vì vậy, 0 sẽ trở thành 00 theo mặc định.

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

Để đầy đủ, nếu bạn muốn biểu diễn thập lục phân bổ sung của hai số âm, bạn có thể sử dụng toán tử dịch chuyển zero-fill-right>>> . Ví dụ:

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

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

Tuy nhiên, có một hạn chế: Các toán tử bitwise JavaScript xử lý các toán hạng của chúng như một chuỗi 32 bit , nghĩa là bạn có được phần bù hai bit 32 bit.

Với phần đệm:

function dec2hex(i) {
   return (i+0x10000).toString(16).substr(-4).toUpperCase();
}

Không có vòng lặp:

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

Ngoài ra, tốt hơn hết là không sử dụng các bài kiểm tra vòng lặp phải được đánh giá?

Ví dụ: thay vì:

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

có

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

Kết hợp một số ý tưởng hay này cho hàm RGB-value-to-hexadecimal (thêm các vị trí #khác cho 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);
}

Câu trả lời được chấp nhận không đưa vào tài khoản một chữ số trả về mã thập lục phân. Điều này dễ dàng được điều chỉnh bởi:

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

và

function strHex(s)
{
    var a = "";
    for (var i=0; i<s.length; i++) {
        a = a + numHex(s.charCodeAt(i));
    }

    return a;
}

Tôi tin rằng các câu trả lời trên đã được đăng bởi nhiều người dưới hình thức này hay hình thức khác. Tôi gói chúng trong hàm toHex () như vậy:

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

Lưu ý rằng biểu thức chính quy số đến từ 10+ Hàm biểu thức chính quy JavaScript hữu ích để cải thiện hiệu quả ứng dụng web của bạn .

Cập nhật: Sau khi kiểm tra điều này nhiều lần tôi đã tìm thấy một lỗi (dấu ngoặc kép trong RegExp), vì vậy tôi đã sửa nó. TUY NHIÊN! Sau khá nhiều thử nghiệm và đã đọc bài đăng của almaz - tôi nhận ra rằng tôi không thể có được số âm để làm việc.

Hơn nữa - Tôi đã đọc một số điều này và vì tất cả các số JavaScript được lưu trữ dưới dạng các từ 64 bit cho dù thế nào - tôi đã thử sửa đổi mã numHex để có được từ 64 bit. Nhưng hóa ra bạn không thể làm điều đó. Nếu bạn đặt "3.14159265" NHƯ MỘT SỐ vào một biến - tất cả những gì bạn có thể nhận được là "3", vì phần phân số chỉ có thể truy cập bằng cách nhân số đó với mười (IE: 10.0) nhiều lần. Hoặc nói theo cách khác - giá trị thập lục phân 0xF làm cho giá trị dấu phẩy động được dịch thành một số nguyên trước khi ANDed loại bỏ mọi thứ phía sau dấu chấm . Thay vì lấy toàn bộ giá trị (ví dụ: 3.14159265) và ANDing giá trị dấu phẩy động so với giá trị 0xF.

Vì vậy, điều tốt nhất để làm, trong trường hợp này là chuyển đổi 3.14159265 thành một chuỗi và sau đó chỉ cần chuyển đổi chuỗi. Do những điều trên, nó cũng giúp bạn dễ dàng chuyển đổi các số âm vì dấu trừ chỉ trở thành 0x26 ở mặt trước của giá trị.

Vì vậy, những gì tôi đã làm là xác định rằng biến chứa một số - chỉ cần chuyển đổi nó thành một chuỗi và chuyển đổi chuỗi. Điều này có nghĩa với tất cả mọi người rằng về phía máy chủ, bạn sẽ cần mở chuỗi chuỗi đến và sau đó để xác định thông tin đến là số. Bạn có thể làm điều đó một cách dễ dàng bằng cách chỉ cần thêm "#" vào phía trước các số và "A" ở phía trước chuỗi ký tự quay lại. Xem hàm toHex ().

Chúc vui vẻ!

Sau một năm nữa và suy nghĩ rất nhiều, tôi quyết định rằng hàm "toHex" (và tôi cũng có chức năng "fromHex") thực sự cần phải được tân trang lại. Toàn bộ câu hỏi là "Làm thế nào tôi có thể làm điều này hiệu quả hơn?" Tôi đã quyết định rằng một hàm đến / từ thập lục phân không nên quan tâm nếu một cái gì đó là một phần phân số nhưng đồng thời nó phải đảm bảo rằng các phần phân số được bao gồm trong chuỗi.

Vì vậy, sau đó câu hỏi trở thành, "Làm thế nào để bạn biết bạn đang làm việc với một chuỗi thập lục phân?". Đáp án đơn giản. Sử dụng thông tin tiền chuỗi tiêu chuẩn đã được công nhận trên toàn thế giới.

Nói cách khác - sử dụng "0x". Vì vậy, bây giờ hàm toHex của tôi trông để xem nếu nó đã ở đó và nếu có - nó chỉ trả về chuỗi đã được gửi đến nó. Nếu không, nó chuyển đổi chuỗi, số, bất cứ điều gì. Đây là chức năng toHex được sửa đổi:

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

Đây là một hàm rất nhanh có tính đến các chữ số đơn, số dấu phẩy động và thậm chí kiểm tra xem liệu người đó có gửi một giá trị hex qua để được lục lại không. Nó chỉ sử dụng bốn lệnh gọi hàm và chỉ hai trong số chúng nằm trong vòng lặp. Để bỏ hex các giá trị bạn sử dụng:

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

Giống như hàm toHex (), hàm fromHex () trước tiên tìm "0x" và sau đó nó dịch thông tin đến thành một chuỗi nếu nó chưa phải là một chuỗi. Tôi không biết làm thế nào nó sẽ không phải là một chuỗi - nhưng chỉ trong trường hợp - tôi kiểm tra. Hàm sau đó đi qua, lấy hai ký tự và dịch chúng sang các ký tự ASCII. Nếu bạn muốn nó dịch Unicode, bạn sẽ cần thay đổi vòng lặp thành bốn (4) ký tự cùng một lúc. Nhưng sau đó, bạn cũng cần đảm bảo rằng chuỗi KHÔNG chia hết cho bốn. Nếu có - thì đó là một chuỗi thập lục phân chuẩn. (Hãy nhớ chuỗi có "0x" ở mặt trước của chuỗi.)

Một tập lệnh thử nghiệm đơn giản để chỉ ra rằng -3,14159265, khi được chuyển đổi thành một chuỗi, vẫn là -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;

?>

Do cách JavaScript hoạt động liên quan đến hàm toString (), tất cả các vấn đề đó có thể được loại bỏ mà trước đó đã gây ra sự cố. Bây giờ tất cả các chuỗi và số có thể được chuyển đổi dễ dàng. Hơn nữa, những thứ như các đối tượng sẽ gây ra lỗi do chính JavaScript tạo ra. Tôi tin rằng điều này là tốt như nó được. Cải tiến duy nhất còn lại là để W3C chỉ bao gồm hàm toHex () và fromHex () trong JavaScript.

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

16 là cơ số và có 16 giá trị trong một số thập lục phân :-)

Đối với bất kỳ ai quan tâm, đây là một JSFiddle so sánh hầu hết các câu trả lời cho câu hỏi này .

Và đây là phương pháp tôi đã thực hiện:

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

Ngoài ra, hãy nhớ rằng nếu bạn đang muốn chuyển đổi từ thập phân sang hex để sử dụng trong CSS làm kiểu dữ liệu màu , thay vào đó, bạn có thể thích trích xuất các giá trị RGB từ thập phân và sử dụng rgb () .

Ví dụ: ( 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 + ')')

Đây bộ #some-elementCSS của colortài sản để rgb(64, 62, 154).

Ràng buộc / đệm vào một số ký tự đã đặt:

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

Đây là phiên bản ECMAScript 6 được cắt bớt:

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

Nếu bạn muốn chuyển đổi một số thành biểu diễn thập lục phân của giá trị màu RGBA, tôi đã thấy đây là sự kết hợp hữu ích nhất của một số mẹo từ đây:

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

Nhận xét của AFAIK 57807 là sai và phải là một cái gì đó như: var hex = Number (d) .toString (16); thay vì 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;
}

Và nếu số âm?

Đây là phiên bản của tôi.

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

Tôi đang thực hiện chuyển đổi thành chuỗi hex trong một vòng lặp khá lớn, vì vậy tôi đã thử một số kỹ thuật để tìm ra chuỗi nhanh nhất. Yêu cầu của tôi là có một chuỗi có độ dài cố định và kết quả là mã hóa các giá trị âm đúng (-1 => ff..f).

Đơn giản .toString(16)không làm việc cho tôi vì tôi cần các giá trị âm được mã hóa chính xác. Mã sau đây là mã nhanh nhất tôi đã thử nghiệm cho đến nay trên các giá trị 1-2 byte (lưu ý symbolsxác định số lượng ký hiệu đầu ra bạn muốn nhận, đó là đối với số nguyên 4 byte, nó phải bằng 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;
}

Nó thực hiện nhanh hơn so với .toString(16)các số 1-2 byte và chậm hơn trên các số lớn hơn (khi symbols> = 6), nhưng vẫn vượt trội so với các phương pháp mã hóa giá trị âm đúng cách.

Như câu trả lời được chấp nhận, cách dễ nhất để chuyển đổi từ thập phân sang thập lục phân là var hex = dec.toString(16). Tuy nhiên, bạn có thể thích thêm một chuyển đổi chuỗi, vì nó đảm bảo rằng các biểu diễn chuỗi như "12".toString(16)hoạt động chính xác.

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

Để đảo ngược quá trình, bạn cũng có thể sử dụng giải pháp dưới đây, vì nó thậm chí còn ngắn hơn.

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

Nó dường như chậm hơn trong Google Chrome và Firefox, nhưng nhanh hơn đáng kể trong Opera. Xem http://jsperf.com/hex-to-dec .

Cách chuyển đổi thập phân thành thập lục phân trong JavaScript

Tôi đã không thể tìm thấy một chuyển đổi thập phân đơn giản / thập phân đơn giản thành thập lục phân không liên quan đến sự lộn xộn của các hàm và mảng ... vì vậy tôi phải tự thực hiện điều này.

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

Tổng hợp tất cả lên;

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

Tuy nhiên, nếu bạn không cần phải chuyển đổi nó trở lại thành một số nguyên ở cuối (nghĩa là đối với màu sắc), thì chỉ cần đảm bảo rằng các giá trị không âm sẽ đủ.

Tôi chưa tìm thấy câu trả lời rõ ràng, không có kiểm tra nếu nó âm hay dương, sử dụng hai phần bù (bao gồm số âm). Vì thế, tôi chỉ ra giải pháp của mình cho một byte:

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

Bạn có thể sử dụng hướng dẫn này cho bất kỳ byte số nào, chỉ bạn thêm FFvào những nơi tương ứng. Ví dụ: hai byte:

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

Nếu bạn muốn truyền một số nguyên mảng thành chuỗi thập lục phân:

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

Trong trường hợp bạn đang muốn chuyển đổi thành một đại diện JavaScript hoặc CSS 'đầy đủ', bạn có thể sử dụng một cái gì đó như:

  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

Bạn có thể làm một cái gì đó như thế này trong ECMAScript 6 :

const toHex = num => (num).toString(16).toUpperCase();

Nếu bạn đang tìm cách chuyển đổi các số nguyên lớn, tức là Số lớn hơn Number.MAX_SAFE_INTEGER - 9007199254740991, thì bạn có thể sử dụng mã sau

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

Điều này dựa trên các giải pháp của Prestaul và Tod. Tuy nhiên, đây là một khái quát hóa chiếm kích thước khác nhau của một biến (ví dụ: Phân tích giá trị đã ký từ nhật ký nối tiếp vi điều khiển).

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

Kịch bản thử nghiệm:

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

Kết quả kiểm tra:

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'

Lưu ý: Không quá chắc chắn tại sao nó thất bại trên 32 bitize

Đây là giải pháp của tôi:

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

Câu hỏi cho biết: "Cách chuyển đổi thập phân thành thập lục phân trong JavaScript" . Trong khi, câu hỏi không xác định rằng chuỗi thập lục phân nên bắt đầu với một 0x tiền tố, bất cứ ai viết code nên biết rằng 0x được thêm vào mã thập lục phân để phân biệt mã thập lục phân từ định danh chương trình và số khác (1234 có thể là hệ thập lục phân, thập phân, hoặc chẵn bát phân).

Do đó, để trả lời chính xác câu hỏi này, với mục đích viết kịch bản, bạn phải thêm tiền tố 0x.

Hàm Math.abs (N) chuyển đổi các phủ định thành tích cực và như một phần thưởng, nó không giống như ai đó đã điều hành nó thông qua một máy băm gỗ.

Câu trả lời tôi muốn, sẽ có một công cụ xác định độ rộng trường, vì vậy, ví dụ chúng ta có thể hiển thị các giá trị 8/16 / 32/64-bit theo cách bạn sẽ thấy chúng được liệt kê trong ứng dụng chỉnh sửa thập lục phân. Đó là câu trả lời đúng, thực tế.