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

질문자 :Luke Smith

JavaScript에서 10진수 값을 해당하는 16진수로 어떻게 변환합니까?

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

 hexString = yourNumber.toString(16);

다음을 사용하여 프로세스를 반대로 하십시오.

 yourNumber = parseInt(hexString, 16);

Prestaul

비트 필드 또는 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));

Tod

아래 코드는 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; }

Luke Smith

function toHex(d) { return ("0"+(Number(d).toString(16))).slice(-2).toUpperCase() }

Baznr

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

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

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

Alberto

패딩 포함:

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

Fabio Ferrari

루프 없이:

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

mystifeid

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

Keith Mashinter

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

더 나아가 - 나는 이것에 대해 약간 읽었고 모든 JavaScript 숫자는 상관없이 64비트 단어로 저장되기 때문에 - 64비트 단어를 얻기 위해 numHex 코드를 수정하려고 시도했습니다. 그러나 당신은 그렇게 할 수 없다는 것이 밝혀졌습니다. "3.14159265" AS A NUMBER를 변수에 넣으면 "3"만 얻을 수 있습니다. 분수 부분은 숫자에 10(IE:10.0)을 반복해서 곱해야만 액세스할 수 있기 때문입니다. 또는 다르게 말하면 - 0xF의 16진수 값은 부동 소수점 값이 AND 처리되기 전에 정수 로 변환되어 마침표 뒤에 있는 모든 것을 제거합니다. 전체 값(예: 3.14159265)을 취하고 부동 소수점 값을 0xF 값에 대해 AND 연결하는 대신.

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

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

즐거운 시간 보내세요!

1년이 더 지나고 많은 생각을 한 끝에 "toHex" 기능(또한 "fromHex" 기능도 있음)을 개선해야 한다고 결정했습니다. 전체 질문은 "이 작업을 어떻게 더 효율적으로 수행할 수 있습니까?"였습니다. 나는 to/from 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가 JavaScript에 toHex() 및 fromHex() 함수를 포함하는 것입니다.

Mark Manning

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

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

Danny Wilson

관심 있는 사람 을 위해 이 질문에 대한 대부분의 답변을 비교하는 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 color 속성을 rgb(64, 62, 154) 합니다.

Hat

설정된 문자 수로 제한/패딩:

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

Adamarla

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 }

Fred

숫자를 RGBA 색상 값의 16진수 표현으로 변환하려는 경우 여기에서 제공하는 몇 가지 팁의 가장 유용한 조합을 찾았습니다.

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

korona

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

Community Wiki

그리고 숫자가 음수라면?

여기 내 버전이 있습니다.

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

Eliarh

꽤 큰 루프에서 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) 보다 빠르고 큰 숫자에서는 느리게 수행 symbols >= 6인 경우) 여전히 음수 값을 올바르게 인코딩하는 방법보다 성능이 뛰어납니다.

almaz

허용되는 답변에서 알 수 있듯이 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 를 참조하십시오.

R D

JavaScript에서 10진수를 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

JonLikeSquirrel

ECMAScript 6 에서 다음과 같이 할 수 있습니다.

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

Alireza

요약하자면;

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

그러나 끝에 정수로 다시 변환할 필요가 없다면(즉, 색상의 경우) 값이 음수가 아닌지 확인하는 것으로 충분합니다.

realkstrawn93

음수인지 양수인지 확인하지 않고 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); }

Francisco Manuel Garca Botella

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

dhc

큰 정수, 즉 Number.MAX_SAFE_INTEGER -- 9007199254740991보다 큰 숫자를 변환하려는 경우 다음 코드를 사용할 수 있습니다.

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

Abhilash Nayak

이것은 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비트 크기 이상에서 실패하는 이유는 확실하지 않습니다.

Brian

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

• rgb(255, 255, 300) // FFFFFF를 반환

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

Bohdan Sych

임의의 정밀도

이 솔루션은 입력 10진수 문자열을 사용하고 16진수 문자열을 반환합니다. 소수점 이하 자릿수가 지원됩니다. 연산

• 숫자를 부호( s ), 정수 부분( i ) 및 분수 부분( f )으로 -123.75 경우 s=true , i=123 , f=75
• 16진수 정수 부분:
  • i='0' 중지
  • 모듈로 얻기: m=i%16 (임의 정밀도로)
  • m 을 16진수로 변환하고 결과 문자열에 넣습니다.
  • 다음 단계 계산 정수 부분 i=i/16 (임의 정밀도)
• 분수 부분
  • 소수 자릿수 n
  • k=f*16 곱하기(임의 정밀도)
  • k n 자리의 오른쪽 부분으로 나누어 f 에 넣고 왼쪽 부분을 나머지 d
  • d 를 16진수로 변환하고 결과에 추가합니다.
  • 결과 소수 자릿수가 충분하면 완료

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

Kamil Kiełczewski

내 솔루션은 다음과 같습니다.

 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) 함수는 음수를 양수로 변환하고 보너스로 누군가가 나무 깎는 기계를 통해 실행한 것처럼 보이지 않습니다.

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

Hypersoft Systems

출처 : http:www.stackoverflow.com/questions/57803/how-to-convert-decimal-to-hexadecimal-in-javascript