So konvertieren Sie Dezimalzahlen in Hexadezimalzahlen in JavaScript

StackOverflow https://stackoverflow.com/questions/57803

Frage

Wie konvertiert man Dezimalwerte in JavaScript in ihr hexadezimales Äquivalent?

War es hilfreich?

Lösung

Konvertieren einer Zahl in eine hexadezimale Zeichenfolge mit: 

hexString = yourNumber.toString(16);

Und umgekehrt den Prozess mit: 

yourNumber = parseInt(hexString, 16);

Andere Tipps

Wenn Sie Dinge wie Bitfelder zu handhaben oder 32-Bit-Farben, dann müssen Sie mit signierten Zahlen beschäftigen. Die JavaScript-Funktion toString(16) eine negative hexadezimale Zahl zurück, die in der Regel nicht das, was Sie wollen. Diese Funktion hat einige verrückte zusätzlich 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 wird den Dezimalwert d in hexadezimal konvertieren. Es erlaubt Ihnen auch padding hexadezimalen Ergebnis hinzuzufügen. So 0 wird 00 werden standardmäßig aktiviert. 

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

Mit padding: 

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

Für die Komplettierung, wenn Sie die Zweierkomplement- hexadezimale Darstellung einer negativen Zahl, können Sie die Null-Füll-rechts Operator Verschiebung >>>. Zum Beispiel: 

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

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

Es gibt jedoch eine Einschränkung: JavaScript Bit-Operatoren behandeln ihre Operanden als eine Folge von 32 Bits , das heißt, bekommen Sie das 32-Bit-zweier-Komplement.

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

Auch ist es nicht besser, nicht Loop-Tests zu verwenden, die ausgewertet werden müssen?

Zum Beispiel statt: 

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

haben 

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

einige dieser guten Ideen für ein RGB-Wert-Hexadezimal-Funktion (fügen Sie den # an anderer Stelle für HTML / CSS) Kombination: 

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 zurückgegebenen Hexadezimalcodes.Dies lässt sich leicht anpassen 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, dass die obigen Antworten in der einen oder anderen Form schon mehrfach von anderen gepostet wurden.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 stammt Über 10 nützliche JavaScript-Funktionen für reguläre Ausdrücke zur Verbesserung der Effizienz Ihrer Webanwendungen.

Aktualisieren:Nachdem ich dieses Ding mehrere Male getestet hatte, fand ich einen Fehler (doppelte Anführungszeichen im RegExp), also habe ich ihn behoben.JEDOCH!Nach einigem Testen und dem Lesen des Beitrags von Almaz wurde mir klar, dass ich negative Zahlen nicht zum Laufen bringen konnte.

Außerdem habe ich etwas darüber nachgelesen und da alle JavaScript-Zahlen auf jeden Fall als 64-Bit-Wörter gespeichert werden, habe ich versucht, den numHex-Code zu ändern, um das 64-Bit-Wort zu erhalten.Aber es stellt sich heraus, dass Sie das nicht tun können.Wenn Sie „3,14159265“ ALS ZAHL in eine Variable eingeben, erhalten Sie nur die „3“, da der Bruchteil nur durch wiederholtes Multiplizieren der Zahl mit zehn (z. B. 10,0) zugänglich ist.Oder anders ausgedrückt: die hexadezimal Der Wert 0xF bewirkt die Gleitkomma Wert, der in einen übersetzt werden soll ganze Zahl bevor es UND-verknüpft wird, wodurch alles hinter dem Punkt entfernt wird.Anstatt den Wert als Ganzes zu nehmen (d. h.:3.14159265) und UND-Verknüpfung Gleitkomma Wert gegen den 0xF-Wert.

In diesem Fall ist es also am besten, 3,14159265 in a umzuwandeln Zeichenfolge und dann einfach die Zeichenfolge konvertieren.Aus diesem Grund ist es auch einfacher, negative Zahlen umzuwandeln, da das Minuszeichen vor dem Wert einfach zu 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 enthexen und dann feststellen müssen, dass die eingehenden Informationen numerisch sind.Sie können dies ganz einfach tun, indem Sie vor Zahlen einfach ein „#“ und vor einer zurückkommenden Zeichenfolge ein „A“ hinzufügen.Siehe die Funktion toHex().

Viel Spaß!

Nach einem weiteren Jahr und langem Nachdenken kam ich zu dem Schluss, dass die „toHex“-Funktion (und ich habe auch eine „fromHex“-Funktion) wirklich überarbeitet werden muss.Die ganze Frage lautete: "Wie kann ich das effizienter tun?" Ich entschied, dass eine bis/aus hexadezimale Funktion es nicht darum kümmert, ob etwas ein fraktionaler Teil ist, aber gleichzeitig sicherstellen sollte, dass fraktionale Teile in der Zeichenfolge enthalten sind.

Dann lautete die Frage: „Woher wissen Sie, dass Sie mit einer hexadezimalen Zeichenfolge arbeiten?“.Die Antwort ist einfach.Verwenden Sie die standardmäßigen Pre-String-Informationen, die weltweit bereits anerkannt sind.

Mit anderen Worten: Verwenden Sie „0x“.Jetzt prüft meine toHex-Funktion, ob das bereits vorhanden ist, und wenn ja, gibt sie einfach die Zeichenfolge zurück, die an sie gesendet wurde.Andernfalls wird die Zeichenfolge, die Zahl usw. konvertiert.Hier ist die überarbeitete toHex-Funktion:////////////////////////////////////////////////// /////////////////////////////// // tohex ().Konvertieren Sie eine ASCII-Zeichenfolge in eine Hexadezimalzeichenfolge.////////////////////////////////////////////////// //////////////////////////////// Tohex (s) {if (substr (0,2) .tolowerCase () == "0x ") { kehrt zurück;}

    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 Gleitkommazahlen berücksichtigt und sogar prüft, ob die Person einen Hexadezimalwert sendet, der erneut verhext werden soll.Es werden nur vier Funktionsaufrufe verwendet und nur zwei davon befinden sich in der Schleife.Um die von Ihnen verwendeten Werte zu enthexen:

/////////////////////////////////////////////////////////////////////////////
//  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 Funktion toHex() sucht die Funktion fromHex() zunächst nach dem „0x“ und übersetzt dann die eingehenden Informationen in einen String, falls es sich noch nicht um einen String handelt.Ich weiß nicht, wieso es kein String wäre – aber nur für den Fall – ich überprüfe es.Anschließend durchläuft die Funktion zwei Zeichen und übersetzt diese in ASCII-Zeichen.Wenn Sie möchten, dass Unicode übersetzt wird, müssen Sie die Schleife auf jeweils vier (4) Zeichen umstellen.Dann müssen Sie aber auch sicherstellen, dass die Zeichenfolge NICHT durch vier teilbar ist.Wenn ja, handelt es sich um eine Standard-Hexadezimalzeichenfolge.(Denken Sie daran, dass am Anfang der Zeichenfolge „0x“ steht.)

Ein einfaches Testskript, um zu zeigen, dass -3.14159265, wenn es in eine Zeichenfolge konvertiert 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 toString()-Funktion können alle Probleme beseitigt werden, die zuvor Probleme verursachten.Jetzt können alle Zeichenfolgen und Zahlen problemlos konvertiert werden.Darüber hinaus führen Dinge wie Objekte dazu, dass JavaScript selbst einen Fehler generiert.Ich glaube, das ist so gut wie es nur geht.Die einzige verbleibende Verbesserung besteht darin, dass W3C lediglich eine toHex()- und fromHex()-Funktion in JavaScript einfügt.

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

Die 16 ist die Radix und es gibt 16 Werte in einer hexadezimalen Zahl: -)

Constrained / gepolsterter auf eine festgelegte Anzahl von Zeichen: 

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

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-Farbwert konvertieren wollen, ich habe dies die sinnvolle Kombination von mehreren Spitzen von hier zu sein gefunden: 

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

57807 Kommentar ist falsch und sollte so etwas wie: var hex = Number (d) .toString (16); Anstatt 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;
}

Für alle Interessierten, hier ist ein JSFiddle die meisten Antworten auf diese Frage gegeben verglichen wird.

Und hier ist die Methode, die ich mit endete gehen: 

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

Auch zu beachten, dass, wenn Sie schauen aus Dezimalzahl in hex zur Verwendung in CSS als rgb () .

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

Dies setzt #some-element CSS color Eigenschaft rgb(64, 62, 154).

Hier ist eine abgespeckte Version 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'

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

Sie können prüfen, das folgende JsFiddle Beispiel oder Stack-Überlauf JavaScript-Beispiel-Code als auch. 

'use strict';

var convertBase = function () {

    function convertBase(baseFrom, baseTo) {
        return function (num) {
            return parseInt(num, baseFrom).toString(baseTo);

        };
    }

    // Decimal to hexadecimal
    convertBase.dec2hex = convertBase(10, 16);
    return convertBase;
}();

alert(convertBase.dec2hex('42')); // '2a'

Ich bin auf Hex-String in einer ziemlich großen Schleife tun Umwandlung, also versuchte ich verschiedene Techniken, um die schnellsten zu finden. Meine Anforderungen waren eine Zeichenfolge fester Länge als Ergebnis haben, und kodieren negative Werte richtig (-1 => ff..f).

Einfache .toString(16) nicht für mich arbeiten, da ich negative Werte benötigt werden, richtig codiert. Der folgende Code ist der schnellste ich bisher auf 1-2-Byte-Werte getestet haben (beachten Sie, dass symbols definiert die Anzahl der Ausgangssymbole Sie erhalten möchten, dh für 4-Byte-Ganzzahl sollte es 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 führt schneller als .toString(16) auf 1-2 Byte-Zahlen und langsamer auf eine größere Anzahl (wenn symbols> = 6), aber immer noch Methoden übertreffen sollte, die richtig negative Werte kodieren.

Wie die akzeptierte Antwort Staaten, der einfachste Weg von Dezimal in hexadezimal zu konvertieren ist var hex = dec.toString(16). Sie können jedoch lieber eine String-Konvertierung hinzuzufügen, wie es richtig, dass die String-Darstellungen wie "12".toString(16) Arbeit gewährleistet. 

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

Um den Vorgang rückgängig machen Sie auch die Lösung unten verwenden, da es noch kürzer ist. 

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

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

Wie Dezimal in hexadezimal in JavaScript umwandeln

war ich nicht in der Lage ein brutal sauber / einfachen Dezimal in hexadezimal Konvertierung zu finden, das nicht ein Chaos von Funktionen und Arrays beinhaltete ... also musste ich diese für mich 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 es zusammenzufassen alle auf; 

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

Allerdings, wenn Sie es nicht am Ende in einer ganzen Zahl konvertieren müssen zurück (das heißt für Farben), dann nur sicherstellen, dass die Werte nicht negativ genügen.

Ich habe keine klare Antwort, ohne Kontrollen gefunden, wenn es negativ oder positiv ist, dass verwendet Zweier-Komplement (negative Zahlen enthalten). Dafür zeige ich meine Lösung zu einem Byte: 

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

Sie können diesen Befehl auf eine beliebige Anzahl Bytes verwenden, können Sie nur FF in den jeweiligen Orten hinzufügen. Zum Beispiel, um zwei Bytes: 

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

Wenn Sie eine Array Ganzzahl Zeichenfolge hexadezimal werfen wollen: 

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

Falls Sie schauen, um eine ‚voll‘ JavaScript oder CSS-Darstellung zu konvertieren, können Sie so etwas wie 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

Sie können in ECMAScript 6 : 

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

Wenn Sie suchen, für die Umwandlung großer Zahlen heißt Zahlen größer als Number.MAX_SAFE_INTEGER - 9007199254740991, dann können Sie den folgenden Code verwenden 

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

Hier ist meine Lösung: 

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

Die Frage sagt: "Wie Dezimal in hexadezimal in JavaScript umwandeln" . Während die Frage nicht an, dass die hexadezimale Zeichenfolge mit einem 0x Präfix beginnen sollte, jeder, den Code schreibt sollte wissen, dass 0x in hexadezimalen Codes hinzugefügt wird, zu unterscheiden Hexadezimal-Codes von programmatischen Bezeichner und andere Zahlen (1234 könnte hexadezimal, dezimal oder sogar oktal sein).

Deshalb, um richtig diese Frage zu beantworten, zum Zweck des Skript-Schreibens, müssen Sie das Präfix 0x hinzuzufügen.

Die Math.abs (N) konvertiert Negative Positive, und als Bonus, es sieht nicht aus wie jemand läuft es durch einen Holzhacker.

Die Antwort, die ich wollte, hätte ein Feld Breitenbezeichner hat, so können wir zum Beispiel zeigen, 16.8 / 32/64-Bit, wie Werte, die Sie sie in einer hexadezimalen Bearbeitungsanwendung aufgeführt würden. Das ist die eigentliche, richtige Antwort.

Lizenziert unter: CC-BY-SA mit Zuschreibung
Nicht verbunden mit StackOverflow
scroll top