Umwandlung von Dezimal- in Hexadezimalzahlen in JavaScript

Question

Wie konvertiert man in JavaScript dezimale Werte in ihr hexadezimales Äquivalent?

Answer 1

Konvertieren einer Zahl in eine hexadezimale Zeichenfolge mit:

hexString = yourNumber.toString(16);

Und kehren Sie den Prozess mit um:

yourNumber = parseInt(hexString, 16);

Answer 2

Wenn Sie Dinge wie Bit-Felder oder 32-Bit-Farben behandeln müssen, dann müssen Sie mit vorzeichenbehafteten Zahlen arbeiten. Die JavaScript-Funktion toString(16) gibt eine negative Hexadezimalzahl zurück, was normalerweise nicht erwünscht ist. Diese Funktion führt eine verrückte Addition durch, 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));

Answer 3

Der nachstehende Code wandelt den Dezimalwert d in Hexadezimalwerte um. Außerdem können Sie das hexadezimale Ergebnis mit einer Füllung versehen. So wird 0 standardmäßig zu 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;
}

Answer 4

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

Answer 5

Die akzeptierte Antwort berücksichtigte keine einstelligen, zurückgegebenen Hexadezimalcodes. Dies lässt sich leicht korrigieren:

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

et

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

    return a;
}

Ich glaube, die oben genannten Antworten wurden bereits mehrfach von anderen in der einen oder anderen Form gepostet. 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 von 10+ Nützliche JavaScript-Funktionen für reguläre Ausdrücke zur Verbesserung der Effizienz Ihrer Webanwendungen .

Update: Nachdem ich das Ding mehrmals getestet habe, habe ich einen Fehler gefunden (doppelte Anführungszeichen in der RegExp), den ich nun behoben habe. WIE AUCH IMMER! Nach etlichen Tests und nachdem ich den Beitrag von almaz gelesen hatte, wurde mir klar, dass ich negative Zahlen nicht zum Laufen bringen konnte.

Weitere - Ich habe einige Lesung auf diese und da alle JavaScript-Zahlen als 64-Bit-Wörter gespeichert werden, egal was - ich versucht, die numHex-Code zu ändern, um die 64-Bit-Wort zu erhalten. Aber es stellt sich heraus, dass Sie das nicht tun können. Wenn Sie "3.14159265" AS A NUMBER in eine Variable - alles, was Sie in der Lage, ist die "3" zu erhalten, weil der gebrochene Teil ist nur zugänglich durch Multiplikation der Zahl mit zehn (IE: 10.0) wiederholt. Oder anders ausgedrückt - die hexadezimal Wert von 0xF bewirkt, dass die Fließkomma Wert, der in eine Ganzzahl bevor es UND-verknüpft wird, wodurch alles hinter dem Punkt entfernt wird. Anstatt den Wert als Ganzes zu nehmen (z.B.: 3.14159265) und die Fließkomma Wert gegen den 0xF-Wert.

In diesem Fall ist es also am besten, die 3,14159265 in eine String und konvertieren Sie dann einfach die Zeichenfolge. Aufgrund der oben genannten, macht es auch einfach, negative Zahlen zu konvertieren, weil das Minuszeichen nur 0x26 auf der Vorderseite des Wertes wird.

Wenn ich also feststelle, dass die Variable eine Zahl enthält, konvertiere ich sie einfach in eine Zeichenkette und konvertiere die Zeichenkette. Das bedeutet für alle, dass Sie auf der Serverseite die eingehende Zeichenkette entschlüsseln und dann feststellen müssen, dass die eingehenden Informationen numerisch sind. Sie können dies einfach tun, indem Sie ein "#" vor Zahlen und ein "A" vor eine zurückkommende Zeichenkette setzen. Siehe die Funktion toHex().

Viel Spaß!

Nach einem weiteren Jahr und vielen Überlegungen kam ich zu dem Schluss, dass die "toHex"-Funktion (und ich habe auch eine "fromHex"-Funktion) wirklich überarbeitet werden muss. Die ganze Frage war: "Wie kann ich das effizienter machen?" Ich beschloss, dass eine Funktion von/nach Hexadezimal egal sein sollte, ob etwas eine Nachkommastelle ist, aber gleichzeitig sollte sie sicherstellen, dass Nachkommastellen in der Zeichenkette enthalten sind.

Die Frage war also: "Woher weiß man, dass man mit einer hexadezimalen Zeichenfolge arbeitet?". Die Antwort ist einfach. Verwenden Sie die standardmäßige Pre-String-Information, die bereits weltweit anerkannt ist.

Mit anderen Worten - verwenden Sie "0x". Jetzt schaut meine toHex-Funktion, ob das schon da ist, und wenn ja, gibt sie einfach die Zeichenfolge zurück, die an sie gesendet wurde. Andernfalls konvertiert sie die Zeichenkette, die Zahl oder was auch immer. 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 und Fließkommazahlen berücksichtigt und sogar prüft, ob die Person einen Hex-Wert sendet, um ihn erneut zu hexen. Sie benötigt nur vier Funktionsaufrufe, von denen nur zwei in der Schleife stehen. Zum Enthexen der Werte verwenden Sie:

/////////////////////////////////////////////////////////////////////////////
//  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 auch die Funktion fromHex() zunächst nach dem "0x" und übersetzt dann die eingehenden Informationen in eine Zeichenkette, wenn es sich nicht bereits um eine Zeichenkette handelt. Ich wüsste nicht, warum es keine Zeichenkette sein sollte - aber sicherheitshalber überprüfe ich das. Die Funktion geht dann durch, schnappt sich zwei Zeichen und übersetzt diese in ASCII-Zeichen. Wenn Sie möchten, dass sie Unicode übersetzt, müssen Sie die Schleife so ändern, dass sie vier (4) Zeichen auf einmal durchläuft. Aber dann müssen Sie auch sicherstellen, dass die Zeichenkette NICHT durch vier teilbar ist. Wenn dies der Fall ist, handelt es sich um eine standardmäßige hexadezimale Zeichenfolge. (Denken Sie daran, dass die Zeichenfolge ein "0x" vorangestellt hat).

Ein einfaches Testskript, um zu zeigen, dass -3.14159265, wenn es in eine Zeichenkette umgewandelt wird, 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 all die Probleme beseitigt werden, die zuvor Probleme verursacht haben. Jetzt können alle Zeichenketten und Zahlen problemlos umgewandelt werden. Außerdem wird JavaScript selbst bei Objekten einen Fehler erzeugen. Ich glaube, das ist so gut wie möglich. Die einzige Verbesserung, die noch aussteht, ist, dass das W3C eine toHex()- und fromHex()-Funktion in JavaScript einbaut.