JavaScript에서 십진수를 16진수로 변환하는 방법

JavaScript에서 십진수를 16진수로 변환하는 방법

JavaScript에서 10진수 값을 16진수 등가로 변환하려면 어떻게 해야 합니까?

다음을 사용하여 숫자를 16진수 문자열로 변환합니다.

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

다음 코드는 10진수 값 d를 16진수로 변환합니다.또한 16진수 결과에 패딩을 추가할 수도 있습니다.디폴트로는 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()
}

완전성을 위해 음수를 두 개의 보완 16진수로 표현하려면 0 채우기-오른쪽 이동 연산자를 사용할 수 있습니다.예:

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

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

단 한 가지 제한이 있습니다. JavaScript 비트 연산자는 피연산자를 32비트의 시퀀스로 취급합니다.즉, 32비트의 2의 보수가 됩니다.

패딩 포함:

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

받아들여진 답변에서는 반환된16진수 코드는 고려되지 않았습니다.이는 다음과 같이 쉽게 조정할 수 있습니다.

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 정규 표현 함수에서 나온 것입니다.

업데이트 : 여러 번 테스트한 결과 오류(RegExp에 큰따옴표)가 발견되어 수정하였습니다.하지만! 꽤 많은 테스트를 하고 알마즈의 투고를 읽은 후, 나는 마이너스 숫자를 얻을 수 없다는 것을 깨달았다.

또한 어떤 경우에도 자바스크립트 번호가 64비트 워드로 저장되기 때문에 64비트 워드를 얻기 위해 numHex 코드를 수정해 보았습니다.하지만 당신은 그것을 할 수 없다는 것이 판명되었다.변수에 "3.14159265" AS NUMBER를 입력하면 - "3"만 얻을 수 있습니다. 왜냐하면 소수 부분에 10을 곱해야만 접근할 수 있기 때문입니다.IE:10.0)을 반복합니다.즉, 16진수 값이 0xF이면 부동소수점 값이 앤딩되기 전에 정수로 변환되어 마침표 뒤에 있는 모든 값이 삭제됩니다.전체 값(예: 3.14159265)을 취하여 부동소수점 값을 0xF 값에 대해 AND화하는 대신,

따라서 이 경우 3.14159265를 문자열로 변환한 후 문자열을 변환하는 것이 가장 좋습니다.이 때문에 마이너스 기호가 값의 앞부분에서 0x26이 되기 때문에 음수 변환도 쉬워집니다.

그래서 제가 한 일은 변수가 숫자를 포함하고 있는지 확인하는 것이었습니다. 그냥 그것을 문자열로 변환하고 문자열을 변환합니다.이것은, 서버측에서 착신 스트링의 hex를 해제해, 착신 정보가 수치인 것을 확인할 필요가 있는 것을 의미합니다.숫자 앞에 '#'을 붙이고 문자열 앞에 'A'를 붙이면 됩니다.toHex() 함수를 참조하십시오.

재미있게 보내!

1년 더 고민한 끝에 'ToHex' 기능(그리고 'fromHex' 기능도 가지고 있다)의 개선이 정말 필요하다고 판단했습니다.모든 질문은 "어떻게 하면 더 효율적으로 할 수 있을까?"였습니다.나는 16진수 함수에 어떤 것이 소수 부분인지 신경 쓰지 않고 동시에 소수 부분이 문자열에 포함되도록 해야 한다고 결정했다.

그래서 질문은 "16진수 문자열로 작업하고 있는지 어떻게 알 수 있는가?"가 되었습니다.대답은 간단하다.전 세계에서 이미 인식되고 있는 표준 프리스트링 정보를 사용합니다.

즉, "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;
}

이는 매우 빠른 함수이며, 한 자리 숫자, 부동 소수점 번호를 고려하며, 사용자가 16진수 값을 다시 보내 16진수되는지 여부도 확인합니다.4개의 함수 콜만 사용하며 그 중 2개만 루프에 있습니다.사용하고 있는 값의 hex를 해제하려면:

/////////////////////////////////////////////////////////////////////////////
//  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"를 검색한 후 아직 문자열이 아닌 경우 수신 정보를 문자열로 변환합니다.어떻게 끈이 아닐지 모르겠지만 혹시 모르니까 확인해볼게요.그 후, 2개의 문자를 취득해, 그것들을 ASCII 문자로 변환하는 기능이 실행됩니다.유니코드를 변환하려면 루프를 한 번에 4자씩 이동하도록 변경해야 합니다.그 다음 끈이 4로 나누어지지 않도록 해야 합니다.이 문자열이 -일 경우 표준 16진수 문자열입니다(문자열 앞에는 "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() 함수를 포함하기만 하면 됩니다.

루프가 없는 경우:

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++){}

함수 값에서 16진수 함수 ):# : "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 decimalToHex(decimal, chars) {
    return (decimal + Math.pow(16, chars)).toString(16).slice(-chars).toUpperCase();
}

이 질문에 대한 대부분의 답변을 비교한 JSFiddle을 소개합니다.

다음은 제가 선택한 방법입니다.

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

---

또한 CSS에서 컬러 데이터 유형으로 사용하기 위해 10진수에서 16진수로 변환하는 경우 대신 10진수에서 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 © CSScolor을 property property로 설정합니다.rgb(64, 62, 154).

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

16은 기수이며 16진수에는 16개의 값이 있습니다:-).

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 색상 값의 16진수 표현으로 변환하는 경우, 여기서 몇 가지 팁을 조합하는 것이 가장 유용하다는 것을 알게 되었습니다.

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

AFIK 코멘트 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);
}

은 16진수입니다.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 를 참조해 주세요.

꽤 큰 루프에서 16진수 스트링으로 변환하고 있기 때문에 가장 빠른 스트링을 찾기 위해 몇 가지 방법을 시도했습니다.그 결과 고정 길이의 문자열을 가지고 음의 값을 올바르게 인코딩해야 했습니다(-1 => ff).f)

한 '심플한'.toString(16)제대로 부호화하려면 음의 값이 필요했기 때문에 효과가 없었습니다.에 대해 지금까지 것 중 : 1-2바이트 값symbols즉, 의 경우 8과 는 과 같습니다.즉, 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) ~ 2(1 ~2 바이트의 경우)symbols>= 6). 단, 음의 값을 올바르게 인코딩하는 메서드보다 성능이 우수합니다.

JavaScript에서 십진수를 16진수로 변환하는 방법

함수나 배열이 뒤죽박죽이 되어 있지 않은, 매우 깨끗한/단순한 10진수에서 16진수로의 변환을 찾을 수 없었습니다.그래서 직접 만들어야 했습니다.

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

큰 정수를 변환하려는 경우.숫자보다 큰 숫자입니다.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;
}

단, 마지막에 다시 정수로 변환할 필요가 없는 경우(색상의 경우), 값이 음수가 되지 않는지 확인하는 것만으로 충분합니다.

음수인지 양수인지를 확인하지 않고 2의 보수를 사용하는 명확한 답을 찾지 못했습니다(음수 포함).이를 위해 솔루션을 1바이트로 표시합니다.

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

는 임의의 수에 할 수 단, 「」를 추가하는 것입니다.FF2바이트로 다음과 같이 됩니다.를를 2 、 2 바 :

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

배열 정수를 문자열 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

이는 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비트 이상에서 장애가 발생하는 이유는 잘 모르겠습니다.

• rgb(255, 255, 255) // FFFFF를 반환합니다.

• rgb(255, 255, 300) // FFFFF를 반환합니다.

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

16진수 색상 숫자를 16진수 색상 문자열로 변환:

심플한 솔루션toString및 ES6padStart16진수 색상의 숫자를 16진수 색상의 문자열로 변환합니다.

const string = `#${color.toString(16).padStart(6, '0')}`;

예를 들어 다음과 같습니다.

0x000000될 것이다#000000
0xFFFFFF될 것이다#FFFFFF

여기서 이 예를 확인해 주세요.

임의 정밀도

이 솔루션은 10진수 문자열을 입력하고 16진수 문자열을 반환합니다.소수점이 지원됩니다.알고리즘.

• 서명할 분할 번호(s정수 부분( )i( ) 및 부분)f예)-123.75우리는 가지고 있다.s=true,i=123,f=75
• 16진수까지의 정수 부분:
  • 한다면i='0'이제 그만
  • 모듈로 가져오기:m=i%16(임의의 정밀도로)
  • 개종시키다m16진수로 결과 문자열에 입력하다
  • 다음 단계 계산 정수 부분의 경우i=i/16(임의의 정밀도로)
• 분수 부분
  • 소수 자릿수를 세다n
  • 곱하다k=f*16(임의의 정밀도로)
  • 분열되다k결별을 고치다n디지트 및 디지트 설정f, 나머지 자릿수는 그대로 두었습니다.d
  • 개종시키다d16진수를 더해서 결과를 더합니다.
  • 결과 소수 자릿수가 충분할 때 완료

// @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));

문제는 기본적으로 몇 개의 패딩 제로를 예상하느냐입니다.

문자열이 필요한 경우01그리고.111번과 17번부터 Buffer를 브릿지로 사용하는 것이 좋습니다.Buffer를 사용하여 숫자를 바이트로 변환하고 16진수는 출력 형식일 뿐입니다.또한 바이트 구성은 쓰기 등의 버퍼 함수에 의해 잘 제어됩니다.UInt32BE, writeInt16LE 등

import { Buffer } from 'buffer';

function toHex(n) { // 4byte
  const buff = Buffer.alloc(4);
  buff.writeInt32BE(n);
  return buff.toString('hex');
}

> toHex(1)
'00000001'
> toHex(17)
'00000011'
> toHex(-1)
'ffffffff'
> toHex(-1212)
'fffffb44'
> toHex(1212)
'000004bc'

제 해결책은 다음과 같습니다.

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

질문은 "JavaScript에서 10진수를 16진수로 변환하는 방법"입니다.이 질문에서는 16진수 문자열이 0x 프리픽스로 시작하는 것은 지정되어 있지 않지만 코드를 쓰는 사람은 16진수 코드에 0x가 추가되어 16진수 코드와 프로그램 ID 및 기타 숫자(1234는 16진수, 10진수 또는 8진수)를 구별할 수 있음을 알아야 합니다.

따라서 이 질문에 올바르게 답하려면 스크립트를 작성하기 위해 0x 프리픽스를 추가해야 합니다.

Math.abs(N) 함수는 음수를 양수로 변환하며, 보너스로는 누군가가 우드칩퍼에서 음수를 실행한 것처럼 보이지 않습니다.

원하는 답변에는 필드 폭 지정자가 포함되어 있기 때문에 예를 들어 8/16/32/64비트 값을 16진수 편집 응용 프로그램에서 볼 수 있는 것처럼 표시할 수 있습니다.이것이 실제 정답입니다.

언급URL : https://stackoverflow.com/questions/57803/how-to-convert-decimal-to-hexadecimal-in-javascript