Wie konvertieren von dezimal in hexadezimal in JavaScript

Konvertieren einer Zahl in eine hexadezimale Zeichenfolge mit:

hexString = yourNumber.toString(16);

Und den Prozess umkehren mit:

yourNumber = parseInt(hexString, 16);

Den code unten konvertieren Sie den Dezimalwert d hexadezimal. Es ermöglicht auch das hinzufügen Polsterung an der hexadezimale Ergebnis. Also 0 wird 00 standardmäßig.

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

Mit Polsterung:

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

Ohne 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 auch nicht es besser, nicht zu verwenden, loop-tests, die bewertet werden müssen?

Z. B. anstelle von:

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

haben

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

Akzeptiert die Antwort nicht berücksichtigen einstelligen zurückgegeben hexadezimal-codes. Dies kann einfach eingestellt werden 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;
}

Glaube ich, dass die obigen Antworten gepostet wurden mehrfach von anderen in der einen oder anderen form. Ich wickeln Sie diese in ein 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 die numerischen regulären Ausdruck kamen aus 10+ Nützliche JavaScript Regular Expression-Funktionen zur Verbesserung Ihrer web-Anwendungen Effizienz.

Update: Nach dem Test das Ding ein paar mal fand ich einen Fehler (doppelte Anführungszeichen in der RegExp), so fixiert, dass ich. ALLERDINGS! Nach ein bisschen testen und Lesen Sie den Beitrag von almaz - ich erkannte, dass ich konnte nicht bekommen, die negativen zahlen zu arbeiten.

Weiter - ich habe einige Bücher zu Lesen, bis auf diese, und da alle JavaScript-zahlen gespeichert werden, 64 bit-Worten, egal was - ich habe versucht, ändern die numHex code ein, um die 64-bit-Wort. Aber es stellt sich heraus können Sie nicht tun. Wenn Sie "3.14159265" ALS ZAHL in eine variable - alle werden Sie in der Lage zu bekommen, ist die "3", weil der gebrochene Teil ist nur zugänglich durch die Multiplikation der Zahl von zehn(SPRICH:10.0) wiederholt. Oder anders gesagt - die hexadezimale Wert 0xF Ursachen der floating point Wert, übersetzt zu werden in eine integer, bevor es ANDed, die löscht alles hinter der Zeit. Anstatt den Wert als ganzes (d.h.: 3.14159265) und und-Verknüpfung der floating point Wert gegen den Wert 0xF.

Also das beste, was zu tun ist, in diesem Fall, ist die Umwandlung von 3.14159265 in eine string und dann einfach konvertieren Sie die Zeichenfolge. Aufgrund der oben genannten, es macht es auch einfach zu konvertieren negativen zahlen, weil das minus-Zeichen wird einfach 0x26 auf der Vorderseite der Wert.

Also, was ich Tat, war auf die Bestimmung, dass die variable eine Zahl enthält - nur es in einen string konvertieren, und konvertieren Sie die Zeichenfolge. Dies bedeutet, alle, die auf der server-Seite müssen Sie unhex den eingehenden string und dann zu bestimmen, die eingehenden Informationen ist numerisch. Sie können das leicht tun, indem Sie nur ein "#" an die front von zahlen und "A" auf der Vorderseite, an der eine Zeichenkette zurück kommen. Finden Sie die toHex () - Funktion.

Spaß haben!

Nach einem weiteren Jahr und viel nachdenken habe ich beschlossen, dass die "toHex" - Funktion (und ich habe auch einen "fromHex" - Funktion) wirklich nötig überarbeitet werden. Die ganze Frage war: "Wie kann ich das effizienter machen?" Ich entschied, dass ein vom/hexadezimal-Funktion sollte sich nicht darum kümmern, wenn etwas ist, einen Bruch, aber zur gleichen Zeit es sollte sicherstellen, dass die Bruch-Teile sind im string enthalten.

Also dann die Frage geworden ist, "Wie tun Sie wissen, Sie arbeiten mit einem hexadezimal-string?". Die Antwort ist einfach. Verwenden Sie die standard-pre-string Informationen, die bereits auf der ganzen Welt anerkannt.

In anderen Worten, verwenden Sie "0x". So nun meine toHex-Funktion sucht, um zu sehen, ob das schon da ist und wenn es ist - es gibt den string, der gesendet wurde, um es. Andernfalls konvertiert die Zeichenfolge, eine Zahl, was auch immer. Hier ist die überarbeitete toHex Funktion:
/////////////////////////////////////////////////////////////////////////////
//toHex(). Konvertiert einen ASCII-string in hexadezimal.
/////////////////////////////////////////////////////////////////////////////
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 berücksichtigt, die einzelnen Ziffern, Gleitkomma-zahlen, und auch überprüft, um zu sehen, ob die person sendet einen hex-Wert über verhext wieder. Es verwendet nur vier Funktionsaufrufe und nur zwei von denen sind in der Schleife. Un-hex die Werte, die Sie verwenden:

/////////////////////////////////////////////////////////////////////////////
// fromHex().  Convert a hex string to ASCII text.
/////////////////////////////////////////////////////////////////////////////
fromHex(s)
{
    var start = 0;
    var o = "";

    if (s.substr(0,2) == "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 toHex () - Funktion, die fromHex () - Funktion sucht zuerst nach dem "0x" und dann ist es übersetzt die eingehenden Informationen in einen string, wenn es nicht bereits ein string. Ich weiß nicht, wie es wäre ein string - aber nur für den Fall - ich check. Die Funktion geht dann durch, packte zwei Zeichen und die übersetzung in ASCII-Zeichen. Wenn Sie möchten, es zu übersetzen, Unicode, ändern Sie bitte die Schleife geht durch vier(4) Zeichen in einer Zeit. Aber dann müssen Sie auch, um sicherzustellen, dass der string NICHT durch vier teilbar ist. Wenn es - dann ist es ein standard-hexadezimal-string aus. (Denken Sie daran die Zeichenfolge "0x" auf der Vorderseite des es.)

Ein einfaches test-script zu zeigen, dass -3.14159265, wenn in einen string konvertiert, ist noch -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;

?>

Weil, wie JavaScript funktioniert in Bezug auf die toString () - Funktion, die alle diese Probleme beseitigt werden können, die bisher Probleme verursacht. Nun sind alle strings und zahlen können leicht konvertiert werden. Weiter, solche Dinge als Objekte führt zu einem Fehler, werden generiert durch JavaScript selbst. Ich glaube, das ist in etwa so gut wie es geht. Die einzige Verbesserung, die linke ist für W3C so, dass es nur eine toHex() und fromHex () - Funktion in JavaScript.

Eingeschränkt/aufgefüllt, um eine festgelegte Anzahl von Zeichen:

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

Wenn Sie möchten, um zu konvertieren eine Zahl in eine hexadezimale Darstellung einer RGBA-Farbe Wert ist, ich habe festgestellt, dass dies die nützlichste Kombination aus mehreren Tipps von hier:

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

Für alle interessierten, hier ein JSFiddle Vergleich die meisten Antworten auf diese Frage.

Und hier ist die Methode, die ich landete mit:

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

Auch, Bedenken Sie, dass, wenn Sie schauen, um zu konvertieren von dezimal zu hex für die Verwendung in CSS als Farbe Datentyp, könnten Sie stattdessen lieber zu extrahieren, die RGB-Werte aus dem dezimal-und verwenden rgb().

Beispielsweise (JSFiddle):

var c = 4210330; //your color in decimal format
var rgb = [(c & 0xff0000) >> 16,  (c & 0x00ff00) >> 8,  (c & 0x0000ff)];

//assuming you're using jQuery...
$("#some-element").css("color", "rgb(" + rgb + ")");

Diese Sätze #some-element's CSS color Eigenschaft rgb(64, 62, 154).

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 mache die Konvertierung zu hex string in eine schöne, große Schleife, also versuchte ich verschiedene Techniken, um zu finden, die Schnellste. Meine Anforderungen waren, dass eine Zeichenfolge fester Länge als Ergebnis, und Kodieren negative Werte richtig (-1 => ff..f).

Einfach .toString(16) hat bei mir nicht funktioniert, da ich brauchte, negative Werte werden korrekt codiert. Der folgende code ist der Schnellste den ich getestet habe bisher 1-2-byte-Werte (beachten Sie, dass symbols definiert die Anzahl der output-Symbole, die Sie möchten, zu bekommen, dass ist für 4-byte-integer sollte es gleich 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;
}

Führt es schneller als .toString(16) auf 1-2 byte-zahlen und langsamer bei größeren zahlen (wenn symbols >= 6), aber sollte noch zu übertreffen, Methoden, Kodieren für negative Werte richtig.

Wie konvertieren von dezimal in hexadezimal in JavaScript

War ich nicht in der Lage zu finden eine Brutal reinigen/einfache dezimal zu hexadezimal Konvertierung, die nicht bedeuten, ein Durcheinander von Funktionen und arrays ... also ich musste das für mich.

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

Habe ich nicht gefunden eine klare Antwort, ohne überprüft, ob es negativ oder positiv ist, verwendet Zweierkomplement (negative zahlen enthalten). Dafür zeige ich meine Lösung für ein byte:

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

Können Sie verwenden diese Anweisung, um eine beliebige Anzahl bytes, nur fügen Sie FF in den jeweiligen Orten. Zum Beispiel, um zwei bytes:

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

Wenn Sie möchten, werfen ein array von integer in string, hexadezimal:

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

Können Sie etwas tun, wie dies in ECMAScript 6:

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

Hier ist meine Lösung:

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

Die Frage sagt: "konvertieren dezimal zu hexadezimal in JavaScript". Während die Frage, nicht angeben, dass der hexadezimal-string sollte beginnen mit 0x prefix, wer code schreibt, sollte wissen, dass 0x Hinzugefügt hexadezimal-codes zu unterscheiden hexadezimal-codes von programmatischen Bezeichner und anderen zahlen (1234 sein könnte, hexadezimal, dezimal, oder sogar oktal).

Daher richtig beantworten diese Frage, für die Zwecke der Skript-schreiben, müssen Sie den 0x-Präfix.

Die Mathematik.abs(N) - Funktion wandelt negative zum positiven, und als bonus, es sieht nicht wie jemand, lief es über eine Holz-chipper.

Die Antwort, die ich wollte, hätte ein Feld-Breite Bezeichner, so konnten wir zum Beispiel zeigen, 8/16/32/64-bit-Werte, die Art und Weise, die Sie würden sehen, wie Sie aufgeführt sind in eine hexadezimale editing-Anwendung. Das ist die eigentliche, richtige Antwort.