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

StackOverflow https://stackoverflow.com/questions/57803

문제

JavaScript에서 10진수 값을 16진수 값으로 어떻게 변환합니까?

도움이 되었습니까?

해결책

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

hexString = yourNumber.toString(16);

그리고 다음을 사용하여 프로세스를 반대로 진행하세요.

yourNumber = parseInt(hexString, 16);

다른 팁

비트 필드나 32비트 색상 등을 처리해야 하는 경우 부호 있는 숫자를 처리해야 합니다.자바스크립트 함수 toString(16) 일반적으로 원하는 것이 아닌 음의 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()
}

패딩 포함:

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

완료를 위해 원하는 경우 2의 보수 음수의 16진수 표현을 사용할 수 있습니다. 0 채우기 오른쪽 시프트 >>> 운영자.예를 들어:

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

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

그러나 한 가지 제한 사항이 있습니다. JavaScript 비트 연산자는 피연산자를 32비트 시퀀스로 처리합니다., 즉, 32비트 2의 보수를 얻습니다.

루프가 없으면:

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

허용된 답변은 한 자리 반환된 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의 큰따옴표)를 발견하여 이를 수정했습니다.하지만!꽤 많은 테스트를 거쳐 almaz의 게시물을 읽은 후에 음수를 얻을 수 없다는 것을 깨달았습니다.

추가로 - 나는 이것에 대해 좀 읽었고 모든 JavaScript 숫자는 무슨 일이 있어도 64비트 단어로 저장되기 때문에 - 64비트 단어를 얻기 위해 numHex 코드를 수정해 보았습니다.하지만 그렇게 할 수 없다는 것이 밝혀졌습니다."3.14159265"를 숫자로 변수에 넣으면 "3"만 얻을 수 있습니다. 분수 부분은 숫자에 10(IE:10.0)을 반복적으로 곱해야만 접근할 수 있기 때문입니다.아니면 다른 말로 표현하자면 - 16진수 0xF 값은 부동 소수점 로 변환될 값 정수 기간 뒤의 모든 것을 제거하는 ANDed 전에.가치를 전체적으로 취하는 대신(예:3.14159265) 및 AND 연산 부동 소수점 0xF 값에 대한 값입니다.

따라서 이 경우 가장 좋은 방법은 3.14159265를 끈 그런 다음 문자열을 변환하면 됩니다.위와 같은 이유로 마이너스 기호가 값 앞에 0x26이 되기 때문에 음수 변환도 쉽게 됩니다.

그래서 제가 한 일은 변수에 숫자가 포함되어 있는지 확인하는 것이었습니다. 이를 문자열로 변환하고 문자열을 변환하기만 하면 됩니다.이는 모든 사람에게 서버 측에서 들어오는 문자열을 16진수로 해독한 다음 들어오는 정보가 숫자인지 확인해야 함을 의미합니다.숫자 앞에 "#"을 추가하고 다시 나오는 문자열 앞에 "A"를 추가하면 쉽게 수행할 수 있습니다.toHex() 함수를 참조하세요.

재미있게 보내세요!

1년을 더 고민한 끝에 저는 "toHex" 기능(및 "fromHex" 기능도 있음)을 정말로 개선해야 한다고 결정했습니다.전체 질문은 "어떻게 더 효율적으로 할 수 있습니까?"였습니다. 나는 a to a to hexadecimal function이 무언가가 분수 된 부분인지는 신경 쓰지 않아야한다고 결정했지만 동시에 분수 부품이 문자열에 포함되도록해야합니다.

그래서 질문은 "16진수 문자열로 작업하고 있는지 어떻게 알 수 있습니까?"였습니다.대답은 간단합니다.이미 전 세계적으로 인정되는 표준 사전 문자열 정보를 사용합니다.

즉, "0x"를 사용하십시오.이제 내 toHex 함수는 그것이 이미 존재하는지 확인하고, 존재한다면 전송된 문자열을 반환합니다.그렇지 않으면 문자열, 숫자 등을 변환합니다.수정된 toHex 함수는 다음과 같습니다.//////////////////////////////////////////////////////////////////////////////////4 ////////////////////////// // toHex ().ASCII 문자열을 16진수로 변환합니다.//////////////////////////////////////////////////////////////////////////////////4 /////////////////////////////ohex (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진수 값을 전송하는지 확인하는 매우 빠른 기능입니다.4개의 함수 호출만 사용하고 그 중 2개만 루프에 있습니다.사용하는 값의 16진수를 해제하려면 다음을 수행하세요.

/////////////////////////////////////////////////////////////////////////////
//  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 문자로 변환합니다.유니코드를 번역하려면 루프를 한 번에 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;

?>

toString() 함수와 관련하여 JavaScript가 작동하는 방식으로 인해 이전에 문제를 일으키던 모든 문제가 제거될 수 있습니다.이제 모든 문자열과 숫자를 쉽게 변환할 수 있습니다.또한 객체와 같은 것들은 JavaScript 자체에 의해 오류가 발생하는 원인이 됩니다.나는 이것이 얻는 것만 큼 좋다고 믿습니다.남은 유일한 개선점은 W3C가 JavaScript에 toHex() 및 fromHex() 함수를 포함하는 것입니다.

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

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

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

AFAIK 댓글 57807 잘못되었으며 다음과 같아야 합니다.var hex = Number(d).toString(16);대신에var hex = parsInt(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에서 사용하기 위해 10진수를 16진수로 변환하려는 경우 색상 데이터 유형, 대신 소수점에서 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 예 또는 스택 오버플로 자바스크립트 예시 코드도 있습니다.

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

꽤 큰 루프에서 16진수 문자열로 변환을 수행하고 있으므로 가장 빠른 방법을 찾기 위해 여러 기술을 시도했습니다.내 요구 사항은 결과적으로 고정 길이 문자열을 갖고 음수 값을 올바르게 인코딩하는 것이었습니다(-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), 하지만 여전히 음수 값을 적절하게 인코딩하는 방법보다 성능이 뛰어납니다.

허용되는 답변에서 알 수 있듯이 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.

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

복잡한 함수와 배열을 포함하지 않는 잔인할 정도로 깨끗하고 간단한 십진수를 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

요약하자면;

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

이 명령어를 임의의 숫자 바이트에 사용할 수 있습니다. FF 각각의 장소에.예를 들어, 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

당신은 이런 일을 할 수 있습니다 ECMA스크립트 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에서 10진수를 16진수로 변환하는 방법".질문에서는 16진수 문자열이 0x 접두사로 시작해야 한다고 명시하지 않지만, 코드를 작성하는 사람은 구별을 위해 16진수 코드에 0x가 추가된다는 점을 알아야 합니다. 16진수 코드 ~에서 프로그래밍 방식 식별자 그리고 다른 번호 (1234는 16진수, 10진수 또는 8진수일 수 있습니다.)

따라서 이 질문에 올바르게 대답하려면 스크립트 작성 목적으로 0x 접두사를 추가해야 합니다.

Math.abs(N) 함수는 음수를 양수로 변환하며, 보너스로 누군가가 나무 분쇄기에 통과시킨 것처럼 보이지 않습니다.

제가 원했던 대답에는 필드 너비 지정자가 있었을 것입니다. 따라서 예를 들어 16진수 편집 응용 프로그램에 나열되는 것처럼 8/16/32/64비트 값을 표시할 수 있습니다.그것이 실제 정답입니다.

라이센스 : CC-BY-SA ~와 함께 속성
제휴하지 않습니다 StackOverflow
scroll top