Jeśli chcesz obsłużyć takie rzeczy jak pola bitowe lub 32-bitowe kolory, musisz poradzić sobie z podpisanymi liczbami. Funkcja JavaScript toString(16) zwróci ujemną liczbę szesnastkową, która zazwyczaj nie jest tym, czego chcesz. Ta funkcja robi jakiś szalony dodatek, aby to liczba dodatnia.

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

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

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

Poniższy kod zamieni wartość dziesiętną d na szesnastkową. Umożliwia również dodanie wypełnienia do wyniku szesnastkowego. Tak więc 0 będzie domyślnie 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()
}

Dla kompletności, jeśli chcesz dwa-dopełniacz szesnastkowej reprezentacji liczby ujemnej, możesz użyć zero-fill-right shift >>> operator . Na przykład:

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

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

Istnieje jednak jedno ograniczenie: operatory bitowe JavaScript traktują swoje operandy jako ciąg 32 bitów, to znaczy otrzymujemy dopełniacz 32-bitowych dwójek.

Z wyściółką:

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

Bez pętli:

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

Czy nie lepiej nie używać testów pętli, które muszą zostać ocenione?

Na przykład zamiast:

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

Mieć

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

Łączenie niektórych z tych dobrych pomysłów dla funkcji RGB-value-to-hexadecimal (dodaj # gdzie indziej dla 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);
}

Zaakceptowana odpowiedź nie uwzględniała jednocyfrowych zwracanych kodów szesnastkowych. Jest to łatwo regulowane przez:

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

I

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

    return a;
}

Wierzę, że powyższe odpowiedzi zostały zamieszczone wiele razy przez innych w tej czy innej formie. Zawijam je w funkcję toHex () w ten sposób:

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

Zauważ, że numeryczne Wyrażenie regularne pochodzi z 10 + przydatne funkcje wyrażeń regularnych JavaScript w celu poprawy wydajności aplikacji internetowych.

Update: Po kilkukrotnym przetestowaniu tej rzeczy znalazłem błąd (podwójne cudzysłowy w wyrażeniu regularnym), więc to naprawiłem. Jednak! Po kilku testach i po przeczytaniu postu Almaza-zdałem sobie sprawę, że nie mogę uzyskać ujemnych liczb do pracy.

Dalej-trochę poczytałem na ten temat i ponieważ wszystkie liczby JavaScript są przechowywane jako 64-bitowe słowa bez względu na wszystko-próbowałem zmodyfikować kod numHex, aby uzyskać 64-bitowe słowo. Ale okazuje się, że nie możesz tego zrobić. Jeśli wpiszesz "3.14159265" jako liczbę do zmienna - wszystko, co będziesz w stanie uzyskać, to "3", ponieważ część ułamkowa jest dostępna tylko przez wielokrotne pomnożenie liczby przez dziesięć(tj. Inaczej mówiąc - szesnastkowa wartość 0XF powoduje, że zmiennoprzecinkowa jest tłumaczona na integer, zanim jest ANDed, który usuwa wszystko za kropką. Zamiast przyjmować wartość jako całość (tj.: 3.14159265) i porównywać wartość zmiennoprzecinkową z Wartość 0xF.

Więc najlepszą rzeczą do zrobienia, w tym przypadku, jest przekonwertowanie 3.14159265 na ciąg , a następnie po prostu przekonwertować ciąg. Z powodu powyższego, ułatwia również konwersję liczb ujemnych, ponieważ znak minus po prostu staje się 0x26 z przodu wartości.

Więc to, co zrobiłem, to ustalenie, że zmienna zawiera liczbę - po prostu przekonwertuj ją na łańcuch i przekonwertuj łańcuch. Oznacza to dla wszystkich, że po stronie serwera będziesz musiał przychodzący łańcuch a następnie do określenia przychodzącej informacji jest numeryczny. Możesz to zrobić łatwo, dodając " # "na początku liczb I" A " na początku ciągu znaków. Patrz funkcja toHex ().

Po kolejnym roku i wielu przemyśleniach, zdecydowałem, że funkcja" tohex "(i mam również funkcję" fromHex") naprawdę wymaga odświeżenia. Całe pytanie brzmiało :" jak Mogę to zrobić bardziej efektywnie?"Zdecydowałem, że a do / Z funkcja szesnastkowa nie powinna dbać o to, czy coś jest częścią ułamkową, ale jednocześnie powinna zapewnić, że części ułamkowe są zawarte w łańcuchu.

Wtedy pojawiło się pytanie: "Skąd wiesz, że pracujesz z łańcuchem szesnastkowym?". Odpowiedź jest prosta. Używaj standardowych informacji Pre-string, które są już rozpoznawane na całym świecie.

Innymi słowy-użyj "0x". Więc teraz moja funkcja toHex wygląda, aby zobaczyć, czy to już tam jest, a jeśli jest - to po prostu zwraca łańcuch, który został do niego wysłany. W przeciwnym razie konwertuje łańcuch, liczbę, cokolwiek. Oto poprawiona funkcja 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;
}

Jest to bardzo szybka funkcja, która bierze pod uwagę pojedyncze cyfry, liczby zmiennoprzecinkowe, a nawet sprawdza, czy dana osoba wysyła wartość szesnastkową, aby zostać ponownie przeklęta. Wykorzystuje tylko cztery wywołania funkcji i tylko dwa z nich są w pętli. Aby usunąć-hex wartości, których używasz:

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

Podobnie jak funkcja tohex (), funkcja fromHex () jako pierwsza szuka "0x", a następnie tłumaczy przychodzące informacje na ciąg znaków, jeśli nie jest jeszcze ciągiem znaków. Nie wiem jak to nie byłoby sznurkiem - ale na wszelki wypadek - sprawdzam. Następnie Funkcja Przechodzi, pobierając dwa znaki i tłumacząc je na znaki ASCII. Jeśli chcesz przetłumaczyć Unicode, musisz zmienić pętlę na przechodzącą przez cztery (4) znaki na raz. Ale musisz również upewnić się, że ciąg nie jest podzielny przez cztery. Jeśli jest - to jest standardowy łańcuch szesnastkowy. (Pamiętaj, że ciąg ma "0x" z przodu.)

Prosty skrypt testowy pokazujący, że -3.14159265, po przekonwertowaniu na ciąg znaków, jest nadal -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;

?>

Ze względu na to, jak JavaScript działa w odniesieniu do funkcji toString (), można wyeliminować wszystkie te problemy, które wcześniej powodowały problemy. Teraz wszystkie ciągi i liczby mogą być łatwo konwertowane. Co więcej, takie rzeczy jak obiekty spowodują, że sam JavaScript wygeneruje błąd. I uwierz, że to jest tak dobre, jak tylko się da. Jedyne ulepszenie, jakie pozostało, to to, że W3C zawiera funkcje Tohex() i fromHex () w JavaScript.

Dla wszystkich zainteresowanych, Oto JSFiddle porównujące większość odpowiedzi udzielonych na to pytanie.

A oto metoda, którą wybrałem:

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

Pamiętaj również, że jeśli chcesz przekonwertować z dziesiętnego na szesnastkowy do użytku w CSS jako typ danych koloru , możesz zamiast tego wyodrębnić wartości RGB z dziesiętnego i użyć RGB().

Na przykład (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 + ')')

This sets #some-element'S CSS color własność do rgb(64, 62, 154).

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

16 jest radix i jest 16 wartości w liczbie szesnastkowej: -)

Ograniczone / wyściełane do określonej liczby znaków:

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

Oto skrócona wersja 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'

Jeśli chcesz przekonwertować liczbę na szesnastkową reprezentację wartości koloru RGBA, uznałem to za najbardziej użyteczną kombinację kilku wskazówek z tego miejsca:

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

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
}

AFAIK komentarz 57807 jest zły i powinien być coś w stylu: var hex = Liczba(d).toString (16); zamiast 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;
}

A jeśli liczba jest ujemna?

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

Wykonuję konwersję na ciąg sześciokątny w dość dużej pętli, więc wypróbowałem kilka technik, aby znaleźć najszybszą. Moje wymagania polegały na tym, że w rezultacie otrzymałem ciąg o stałej długości i poprawnie zakodowałem wartości ujemne (-1 = > ff..f).

Proste .toString(16) nie zadziałało dla mnie, ponieważ potrzebowałem wartości ujemnych, aby były poprawnie zakodowane. Poniższy kod jest najszybszy, jaki testowałem do tej pory na wartościach 1-2 bajtów (zauważ, że symbols definiuje liczbę symboli wyjściowych, które chcesz uzyskać, to jest dla 4-bajtowa liczba całkowita powinna być równa 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;
}

Działa szybciej niż .toString(16) na liczbach 1-2 bajtów i wolniej na liczbach większych (gdy symbols >= 6), ale nadal powinny przewyższać metody, które poprawnie kodują wartości ujemne.

Jak stwierdza przyjęta odpowiedź, najprostszym sposobem konwersji z dziesiętnego na szesnastkowy jest var hex = dec.toString(16). Możesz jednak dodać konwersję łańcuchów, ponieważ zapewnia to poprawne działanie reprezentacji łańcuchów, takich jak "12".toString(16).

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

Aby odwrócić proces, możesz również użyć poniższego rozwiązania, ponieważ jest ono jeszcze krótsze.

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

Jak przekonwertować dziesiętne na szesnastkowe w JavaScript

Nie udało mi się znaleźć brutalnie czystej/prostej konwersji dziesiętnej na szesnastkową, która nie wymagała bałaganu funkcji i tablic ... więc musiałem zrobić to dla siebie.

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

Podsumowując to wszystko;

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

Jeśli jednak nie musisz konwertować go z powrotem na liczbę całkowitą na końcu (np. dla kolorów), wystarczy upewnić się, że wartości nie są ujemne.

Nie znalazłem jasnej odpowiedzi, bez sprawdzania, czy jest negatywna czy pozytywna, która używa dopełniacza dwójki(liczby ujemne w zestawie). W tym celu pokazuję moje rozwiązanie na jeden bajt:

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

Możesz użyć tej instrukcji do dowolnej liczby bajtów, tylko dodajesz FF w odpowiednich miejscach. Na przykład do dwóch bajtów:

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

Jeśli chcesz oddać tablicę liczb całkowitych do ciągu szesnastkowego:

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

W przypadku, gdy chcesz przekonwertować na "pełną" reprezentację JavaScript lub CSS, możesz użyć czegoś takiego jak:

  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

Możesz zrobić coś takiego w ECMAScript 6:

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

Jeśli szukasz konwersji dużych liczb całkowitych, tj. liczb większych niż liczba.MAX_SAFE_INTEGER -- 9007199254740991, wtedy możesz użyć następującego kodu

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

Jest to oparte na rozwiązaniach Prestaul i Tod. Jest to jednak uogólnienie, które uwzględnia różną wielkość zmiennej (np. parsowanie podpisanej wartości z dziennika szeregowego mikrokontrolera).

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

Skrypt testowy:

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

Wyniki testu:

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'

Uwaga: Nie jestem pewien, dlaczego nie powiedzie się powyżej 32 bitów

• Rgb (255, 255, 255) // zwraca FFFFFF

• Rgb (255, 255, 300) // zwraca FFFFFF

• Rgb (0,0,0) / / zwraca 000000

• Rgb (148, 0, 211) // zwraca 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();
        }
  

Dowolna precyzja

To rozwiązanie pobiera wejściowy łańcuch dziesiętny i zwraca łańcuch szesnastkowy. Obsługiwane są ułamki dziesiętne. Algorytm

• podziel liczbę na znak (s), część całkowitą (i) i część ułamkową (f) np. dla -123.75 mamy s=true, i=123, f=75
• część całkowita Do hex:
  • if i='0' stop
  • get modulo: m=i%16 (W dowolnej precyzji)
  • Konwertuj m na cyfrę szesnastkową i umieść na łańcuch wyników
  • do następnego kroku calc integer part i=i/16 (W dowolnej precyzji)
• część ułamkowa
  • policz cyfry ułamkowe n
  • mnożenie k=f*16 (w arbitralnej precyzji)
  • podziel k na prawą część z n cyframi i umieść je na f, a lewą część z resztą cyfr i umieść je na d
  • Konwertuj d na hex i dodaj do wyniku.
  • Zakończ, gdy liczba wynikowych cyfr ułamkowych jest wystarczy

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

Oto moje rozwiązanie:

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

Pytanie brzmi: "Jak przekonwertować dziesiętne na szesnastkowe w JavaScript". Podczas gdy pytanie nie określa, że łańcuch szesnastkowy powinien zaczynać się od przedrostka 0x, każdy, kto pisze kod powinien wiedzieć, że 0x jest dodawany do kodów szesnastkowych, aby odróżnić Kody szesnastkowe od identyfikatory programowe i inne liczby (1234 może być szesnastkowy, dziesiętny, a nawet ósemkowy).

Dlatego, aby poprawnie odpowiedz na to pytanie, w celu pisania skryptów musisz dodać prefiks 0x.

Matematyka.funkcja abs(N) konwertuje negatywy na pozytywy, a jako bonus, nie wygląda na to, że ktoś przepuścił ją przez Rębak do drewna.

Odpowiedź, którą chciałem, miała określnik szerokości pola, więc możemy na przykład pokazać wartości 8/16/32/64-bitowe w sposób, w jaki można je zobaczyć w aplikacji do edycji w systemie szesnastkowym. To jest prawdziwa, poprawna odpowiedź.