Konvertieren von Dezimalzahlen in Hexadezimalzahlen in JavaScript

Wie konvertiert man Dezimalwerte in JavaScript in ihre hexadezimale Entsprechung?

Konvertieren Sie eine Zahl in eine hexadezimale Zeichenfolge mit:

hexString = yourNumber.toString(16);

Und kehren Sie den Prozess um mit:

yourNumber = parseInt(hexString, 16);

Wenn Sie mit Bitfeldern oder 32-Bit-Farben umgehen müssen, müssen Sie sich mit vorzeichenbehafteten Zahlen befassen. Die JavaScript-FunktiontoString(16) gibt eine negative Hexadezimalzahl zurück, die normalerweise nicht Ihren Wünschen entspricht. Diese Funktion macht eine verrückte Addition, um daraus eine positive Zahl zu machen.

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

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

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

Der folgende Code konvertiert den Dezimalwert d in hexadezimal. Außerdem können Sie dem hexadezimalen Ergebnis eine Auffüllung hinzufügen. Aus 0 wird also standardmäßig 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()
}

Für Vollständigkeit, wenn Sie das wollen Zweierkomplement- hexadezimale Darstellung einer negativen Zahl, können Sie das verwenden Null-Füll-Verschiebung nach rechts >>>Operator . Zum Beispiel:

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

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

Es gibt jedoch eine Einschränkung: Bitweise JavaScript-Operatoren behandeln ihre Operanden als eine Folge von 32 Bit , dh Sie erhalten das 32-Bit-Zweierkomplement.

Mit Polsterung:

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

Ohne die Schleife:

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

Ist es auch nicht besser, keine Schleifentests zu verwenden, die ausgewertet werden müssen?

Zum Beispiel anstelle von:

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

haben

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

Kombinieren Sie einige dieser guten Ideen für eine RGB-Wert-zu-Hexadezimal-Funktion (fügen Sie die #andere für HTML / CSS hinzu):

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

Die akzeptierte Antwort berücksichtigte keine einstelligen Hexadezimalcodes. Dies lässt sich leicht einstellen durch:

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

und

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

    return a;
}

Ich glaube, die obigen Antworten wurden mehrfach von anderen in der einen oder anderen Form veröffentlicht. Ich verpacke diese in eine toHex () - Funktion wie folgt:

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

Beachten Sie, dass der numerische reguläre Ausdruck aus 10+ nützlichen Funktionen für reguläre JavaScript-Ausdrücke stammt, um die Effizienz Ihrer Webanwendungen zu verbessern .

Update: Nachdem ich dieses Ding mehrmals getestet hatte, fand ich einen Fehler (doppelte Anführungszeichen in RegExp), also habe ich das behoben. JEDOCH! Nachdem ich einige Tests durchgeführt und den Beitrag von almaz gelesen hatte, wurde mir klar, dass ich keine negativen Zahlen zum Laufen bringen konnte.

Weiter - ich habe etwas darüber gelesen und da alle JavaScript-Nummern als 64-Bit-Wörter gespeichert sind, habe ich versucht, den numHex-Code zu ändern, um das 64-Bit-Wort zu erhalten. Aber es stellt sich heraus, dass Sie das nicht können. Wenn Sie "3.14159265" ALS NUMMER in eine Variable eingeben, erhalten Sie nur die "3", da auf den Bruchteil nur zugegriffen werden kann, indem Sie die Zahl wiederholt mit zehn (IE: 10.0) multiplizieren. Oder anders ausgedrückt: Der Hexadezimalwert von 0xF bewirkt, dass der Gleitkommawert in eine Ganzzahl übersetzt wird, bevor er UND-verknüpft wird, wodurch alles hinter der Periode entfernt wird. Anstatt den Wert als Ganzes zu nehmen (dh: 3.14159265) und den Gleitkomma UND zu verknüpfen gegen den 0xF-Wert UND zu verknüpfen.

In diesem Fall ist es am besten, den 3.14159265 in einen String umzuwandeln und dann einfach den String zu konvertieren. Aus diesem Grund ist es auch einfach, negative Zahlen umzuwandeln, da das Minuszeichen auf der Vorderseite des Werts nur 0x26 wird.

Ich habe also festgestellt, dass die Variable eine Zahl enthält - konvertieren Sie sie einfach in eine Zeichenfolge und konvertieren Sie die Zeichenfolge. Dies bedeutet für alle, dass Sie auf der Serverseite die eingehende Zeichenfolge entfernen und dann feststellen müssen, dass die eingehenden Informationen numerisch sind. Sie können dies einfach tun, indem Sie einfach ein "#" an die Vorderseite der Zahlen und ein "A" an die Vorderseite einer Zeichenfolge einfügen, die zurückkommt. Siehe die Funktion toHex ().

Habe Spaß!

Nach einem weiteren Jahr und viel Nachdenken entschied ich, dass die "toHex" -Funktion (und ich habe auch eine "fromHex" -Funktion) wirklich überarbeitet werden musste. Die ganze Frage war: "Wie kann ich das effizienter machen?" Ich entschied, dass eine to / from-Hexadezimalfunktion sich nicht darum kümmern sollte, ob etwas ein Bruchteil ist, aber gleichzeitig sicherstellen sollte, dass Bruchteile in der Zeichenfolge enthalten sind.

Dann stellte sich die Frage: "Woher wissen Sie, dass Sie mit einer hexadezimalen Zeichenfolge arbeiten?". Die Antwort ist einfach. Verwenden Sie die Standardinformationen vor der Zeichenfolge, die weltweit bereits anerkannt sind.

Mit anderen Worten - verwenden Sie "0x". Meine toHex-Funktion prüft nun, ob dies bereits vorhanden ist und ob dies der Fall ist. Sie gibt nur die Zeichenfolge zurück, die an sie gesendet wurde. Andernfalls wird die Zeichenfolge, die Nummer usw. konvertiert. Hier ist die überarbeitete toHex-Funktion:

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

Dies ist eine sehr schnelle Funktion, die einzelne Ziffern, Gleitkommazahlen und sogar prüft, ob die Person einen Hex-Wert sendet, um ihn erneut zu hexen. Es werden nur vier Funktionsaufrufe verwendet, von denen sich nur zwei in der Schleife befinden. So entsperren Sie die verwendeten Werte:

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

Wie die Funktion toHex () sucht die Funktion fromHex () zuerst nach "0x" und übersetzt dann die eingehenden Informationen in eine Zeichenfolge, wenn es sich nicht bereits um eine Zeichenfolge handelt. Ich weiß nicht, wie es kein String wäre - aber nur für den Fall - ich überprüfe. Die Funktion geht dann durch, greift nach zwei Zeichen und übersetzt diese in ASCII-Zeichen. Wenn Sie möchten, dass Unicode übersetzt wird, müssen Sie die Schleife so ändern, dass sie jeweils vier (4) Zeichen umfasst. Dann müssen Sie aber auch sicherstellen, dass die Zeichenfolge NICHT durch vier teilbar ist. Wenn ja, dann ist es eine hexadezimale Standardzeichenfolge. (Denken Sie daran, dass die Zeichenfolge vorne "0x" hat.)

Ein einfaches Testskript, das zeigt, dass -3.14159265 bei der Konvertierung in eine Zeichenfolge immer noch -3.14159265 ist.

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

?>

Aufgrund der Funktionsweise von JavaScript in Bezug auf die Funktion toString () können alle Probleme behoben werden, die zuvor Probleme verursacht haben. Jetzt können alle Zeichenfolgen und Zahlen einfach konvertiert werden. Darüber hinaus verursachen Objekte wie Objekte einen Fehler, der von JavaScript selbst generiert wird. Ich glaube, das ist ungefähr so ​​gut wie es nur geht. Die einzige verbleibende Verbesserung besteht darin, dass W3C nur die Funktionen toHex () und fromHex () in JavaScript enthält.

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

Die 16 ist der Radix und es gibt 16 Werte in einer Hexadezimalzahl :-)

Für alle Interessierten gibt es hier eine JSFiddle, die die meisten Antworten auf diese Frage vergleicht .

Und hier ist die Methode, mit der ich am Ende angefangen habe:

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

Auch bedenken , dass , wenn Sie schauen aus Dezimalzahl in hex zur Verwendung in CSS als konvertieren Farbe Datentyp , können Sie stattdessen lieber die RGB - Werte aus dem Dezimalsystem und Verwendung extrahieren rgb () .

Zum Beispiel ( 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 + ')')

Dies setzt #some-elementdie CSS- colorEigenschaft aufrgb(64, 62, 154) .

Auf eine festgelegte Anzahl von Zeichen beschränkt / aufgefüllt:

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

Hier ist eine abgespeckte ECMAScript 6-Version:

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
}

Wenn Sie eine Zahl in eine hexadezimale Darstellung eines RGBA-Farbwerts konvertieren möchten, ist dies die nützlichste Kombination mehrerer Tipps von hier:

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

AFAIK- Kommentar 57807 ist falsch und sollte ungefähr so lauten: var hex = Number (d) .toString (16); anstelle von 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;
}

Und wenn die Zahl negativ ist?

Hier ist meine Version.

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

Ich konvertiere in eine ziemlich große Schleife in einen Hex-String, also habe ich verschiedene Techniken ausprobiert, um die schnellste zu finden. Meine Anforderungen waren, eine Zeichenfolge fester Länge zu haben und negative Werte richtig zu codieren (-1 => ff..f).

Simple .toString(16)hat bei mir nicht funktioniert, da ich negative Werte brauchte, um richtig codiert zu werden. Der folgende Code ist der schnellste, den ich bisher mit 1-2-Byte-Werten getestet habe (Hinweis, symbolsder die Anzahl der Ausgabesymbole definiert, die Sie erhalten möchten, dh für eine 4-Byte-Ganzzahl sollte er gleich 8 sein):

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

Es ist schneller als .toString(16)bei 1-2-Byte-Zahlen und langsamer bei größeren Zahlen (wenn symbols> = 6), sollte jedoch Methoden übertreffen, die negative Werte richtig codieren.

Wie in der akzeptierten Antwort angegeben, ist die Konvertierung von dezimal nach hexadezimal am einfachsten var hex = dec.toString(16). Möglicherweise möchten Sie jedoch lieber eine Zeichenfolgenkonvertierung hinzufügen, da dadurch sichergestellt wird, dass Zeichenfolgendarstellungen wie "12".toString(16)korrekt funktionieren.

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

Um den Vorgang umzukehren, können Sie auch die folgende Lösung verwenden, da diese noch kürzer ist.

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

In Google Chrome und Firefox scheint es langsamer zu sein, in Opera jedoch deutlich schneller. Siehe http://jsperf.com/hex-to-dec .

Konvertieren von Dezimalzahlen in Hexadezimalzahlen in JavaScript

Ich war nicht in der Lage, eine brutal saubere / einfache Konvertierung von Dezimal zu Hexadezimal zu finden, die keine Unordnung von Funktionen und Arrays beinhaltete ... also musste ich dies für mich selbst machen.

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

Um alles zusammenzufassen;

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

Wenn Sie es jedoch am Ende nicht wieder in eine Ganzzahl konvertieren müssen (dh für Farben), sollte es ausreichen, nur sicherzustellen, dass die Werte nicht negativ sind.

Ich habe keine klare Antwort gefunden, ohne zu prüfen, ob sie negativ oder positiv ist und das Zweierkomplement verwendet (einschließlich negativer Zahlen). Dafür zeige ich meine Lösung auf ein Byte:

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

Sie können diese Anweisung für eine beliebige Anzahl von Bytes verwenden, die Sie nur FFan den entsprechenden Stellen hinzufügen . Zum Beispiel auf zwei Bytes:

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

Wenn Sie eine Array-Ganzzahl in eine hexadezimale Zeichenfolge umwandeln möchten:

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

Wenn Sie in eine 'vollständige' JavaScript- oder CSS-Darstellung konvertieren möchten, können Sie Folgendes verwenden:

  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

In ECMAScript 6 können Sie Folgendes tun :

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

Wenn Sie große Ganzzahlen konvertieren möchten, dh Zahlen größer als Number.MAX_SAFE_INTEGER - 9007199254740991, können Sie den folgenden Code verwenden

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

Dies basiert auf den Lösungen von Prestaul und Tod. Dies ist jedoch eine Verallgemeinerung, die die unterschiedliche Größe einer Variablen berücksichtigt (z. B. Analysieren des vorzeichenbehafteten Werts aus einem seriellen Protokoll eines Mikrocontrollers).

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

Testskript:

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

Testergebnisse:

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'

Hinweis: Nicht sicher, warum es über 32 Bit Größe fehlschlägt

Hier ist meine Lösung:

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

Die Frage lautet: "Wie konvertiere ich Dezimal in Hexadezimal in JavaScript" . Während die Frage nicht angibt, dass die hexadezimale Zeichenfolge mit einem 0x-Präfix beginnen soll, sollte jeder, der Code schreibt, wissen, dass hexadezimalen Codes 0x hinzugefügt wird, um hexadezimale Codes von programmatischen Bezeichnern und anderen Zahlen zu unterscheiden (1234 kann hexadezimal, dezimal oder sein) sogar oktal).

Um diese Frage richtig zu beantworten, müssen Sie zum Schreiben von Skripten das Präfix 0x hinzufügen.

Die Math.abs (N) -Funktion wandelt Negative in Positive um, und als Bonus sieht es nicht so aus, als hätte jemand sie durch einen Holzhacker laufen lassen.

Die Antwort, die ich wollte, hätte einen Feldbreitenspezifizierer gehabt, so dass wir beispielsweise 8/16/32/64-Bit-Werte so anzeigen könnten, wie Sie sie in einer hexadezimalen Bearbeitungsanwendung sehen würden. Das ist die eigentliche, richtige Antwort.