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

JavaScript에서 십진수 값을 16 진수로 변환하는 방법은 무엇입니까?

다음을 사용하여 숫자를 16 진수 문자열로 변환하십시오.

hexString = yourNumber.toString(16);

그리고 다음과 같이 프로세스를 되돌립니다.

yourNumber = parseInt(hexString, 16);

비트 필드 또는 32 비트 색상과 같은 것을 처리해야하는 경우 부호있는 숫자를 처리해야합니다. JavaScript 함수 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()
}

완전성을 위해 2의 보수 16 진수를 음수로 나타내려면 zero-fill-right shift >>>연산자를 사용할 수 있습니다 . 예를 들어 :

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

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

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

패딩 포함 :

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

루프없이 :

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"AS A NUMBER를 변수에 입력하면 소수 부분에 숫자에 10 (IE : 10.0)을 반복해서 곱해서 만 액세스 할 수 있으므로 "3"만 얻을 수 있습니다. 또는 다른 말로하면-16 진수 값 0xF는 부동 소수점 값 이 AND가되기 전에 정수 로 변환되어 기간 뒤의 모든 것을 제거합니다. 값을 전체 (예 : 3.14159265)로 가져와 0xF 값에 대해 부동 소수점 값을 AND 하는 대신.

따라서이 경우 가장 좋은 방법은 3.14159265를 문자열 로 변환 한 다음 문자열 을 변환하는 것입니다. 위의 값 때문에 마이너스 부호가 값 앞의 0x26이되기 때문에 음수를 쉽게 변환 할 수 있습니다.

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

즐기세요!

또 다른 해와 많은 생각 끝에 "toHex"기능 (및 "fromHex"기능도 있음)을 실제로 개선해야한다고 결정했습니다. 전체 질문은 "어떻게 더 효율적으로 할 수 있습니까?"였습니다. 16 진수로 /부터 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 개만 루프에 있습니다. 사용하는 값의 16 진수를 해제하려면 다음을 수행하십시오.

/////////////////////////////////////////////////////////////////////////////
//  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"를 찾은 다음 들어오는 정보가 아직 문자열이 아닌 경우 문자열로 변환합니다. 나는 그것이 문자열이 아닌 방법을 모르지만 단지 경우에 따라 확인합니다. 그런 다음이 함수는 두 문자를 잡고 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가 toHex () 및 fromHex () 함수를 JavaScript에 포함시키는 것입니다.

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

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

관심있는 사람이라면 이 질문에 주어진 대부분의 답변을 비교하는 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-elementCSS color속성을로 설정 합니다 rgb(64, 62, 154).

설정된 문자 수로 제한 / 채우기 :

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

정리 된 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 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 = 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 진수 문자열로 변환하고 있으므로 가장 빠른 것을 찾기 위해 여러 가지 기술을 시도했습니다. 내 요구 사항은 결과적으로 고정 길이 문자열을 가져야하고 음수 값을 올바르게 인코딩해야합니다 (-1 => ff..f).

.toString(16)제대로 인코딩하려면 음수 값이 필요했기 때문에 Simple 이 작동하지 않았습니다. 다음 코드는 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);

Chrome 및 Firefox에서는 속도가 느리지 만 Opera에서는 속도가 훨씬 빠릅니다. http://jsperf.com/hex-to-dec을 참조하십시오 .

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

요약하면;

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

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)

이것은 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 비트 이상에서 실패하는지 잘 모르겠습니다.

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

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

질문은 "자바 스크립트에서 10 진수를 16 진수로 변환하는 방법" 이라고 말합니다 . 이 질문은 16 진 문자열이 0x 접두사로 시작해야한다고 지정하지 않지만 코드를 작성하는 사람은 16 진 코드 를 프로그래밍 방식 식별자 및 기타 숫자 (1234는 16 진, 10 진수 또는 심지어 8 진).

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

Math.abs (N) 함수는 음수를 양수로 변환하며, 보너스로 누군가 누군가가 나무 칩퍼를 통해 그것을 실행하는 것처럼 보이지 않습니다.

내가 원했던 대답은 필드 너비 지정자를 가졌으므로 예를 들어 8/16/32/64 비트 값을 16 진수 편집 응용 프로그램에 나열된 방식으로 표시 할 수 있습니다. 그것은 실제적이고 정답입니다.