Come convertire i decimali in esadecimali in JavaScript

Come si convertono i valori decimali nel loro equivalente esadecimale in JavaScript?

Converti un numero in una stringa esadecimale con:

hexString = yourNumber.toString(16);

E invertire il processo con:

yourNumber = parseInt(hexString, 16);

Se hai bisogno di gestire cose come campi di bit o colori a 32 bit, allora devi occuparti dei numeri con segno. La funzione JavaScript toString(16)restituirà un numero esadecimale negativo che di solito non è quello desiderato. Questa funzione fa qualche aggiunta folle per renderlo un numero positivo.

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

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

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

Il codice seguente converte il valore decimale d in esadecimale. Inoltre, consente di aggiungere il riempimento al risultato esadecimale. Quindi 0 diventerà 00 per impostazione predefinita.

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

Per completezza, se si desidera la rappresentazione esadecimale del complemento a due di un numero negativo, è possibile utilizzare l' operatore di spostamento zero-fill-right>>> . Per esempio:

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

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

C'è comunque una limitazione: gli operatori bit a bit di JavaScript trattano i loro operandi come una sequenza di 32 bit , ovvero si ottiene il complemento a due bit a 32 bit.

Con imbottitura:

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

Senza il ciclo:

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

Inoltre, non è meglio non usare i loop test che devono essere valutati?

Ad esempio, anziché:

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

avere

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

Combinando alcune di queste buone idee per una funzione da RGB a valore esadecimale (aggiungi #altrove per 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);
}

La risposta accettata non ha tenuto conto dei codici esadecimali restituiti a cifra singola. Questo è facilmente regolabile da:

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

e

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

    return a;
}

Credo che le risposte di cui sopra siano state pubblicate più volte da altri in un modo o nell'altro. Li avvolgo in una funzione toHex () in questo modo:

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

Si noti che l'espressione numerica regolare proviene da oltre 10 utili funzioni JavaScript per le espressioni regolari per migliorare l'efficienza delle applicazioni Web .

Aggiornamento: dopo aver testato questa cosa più volte ho trovato un errore (virgolette doppie in RegExp), quindi l'ho risolto. PERÒ! Dopo un bel po 'di test e dopo aver letto il post di Almaz, mi sono reso conto che non riuscivo a far funzionare i numeri negativi.

Inoltre - ho fatto qualche lettura su questo e dato che tutti i numeri JavaScript sono memorizzati come parole a 64 bit, non importa quale - ho provato a modificare il codice numHex per ottenere la parola a 64 bit. Ma si scopre che non puoi farlo. Se inserisci "3.14159265" COME NUMERO in una variabile, tutto ciò che sarai in grado di ottenere è il "3", perché la parte frazionaria è accessibile solo moltiplicando il numero per dieci (IE: 10.0) ripetutamente. O, in altre parole, il valore esadecimale di 0xF fa sì che il valore in virgola mobile venga tradotto in un numero intero prima che sia ANDed, il che rimuove tutto ciò che sta dietro al punto. Invece di prendere il valore nel suo insieme (cioè: 3.14159265) e ANDing il valore in virgola mobile rispetto al valore 0xF.

Quindi la cosa migliore da fare, in questo caso, è convertire 3.14159265 in una stringa e poi semplicemente convertire la stringa. A causa di quanto sopra, rende anche più semplice la conversione di numeri negativi poiché il segno meno diventa 0x26 sulla parte anteriore del valore.

Quindi quello che ho fatto è stato determinare che la variabile contiene un numero: basta convertirlo in una stringa e convertire la stringa. Questo significa per tutti che sul lato server sarà necessario rimuovere la stringa in entrata e quindi determinare che le informazioni in entrata sono numeriche. Puoi farlo facilmente semplicemente aggiungendo un "#" all'inizio dei numeri e una "A" all'inizio di una stringa di caratteri che ritorna. Vedi la funzione toHex ().

Divertiti!

Dopo un altro anno e molte riflessioni, ho deciso che la funzione "toHex" (e ho anche una funzione "fromHex") doveva davvero essere rinnovata. L'intera domanda era "Come posso farlo in modo più efficiente?" Ho deciso che una funzione esadecimale da / a non dovrebbe interessare se qualcosa è una parte frazionaria ma allo stesso tempo dovrebbe garantire che le parti frazionarie siano incluse nella stringa.

Quindi la domanda divenne: "Come fai a sapere che stai lavorando con una stringa esadecimale?". La risposta è semplice Utilizzare le informazioni pre-stringa standard già riconosciute in tutto il mondo.

In altre parole, usa "0x". Quindi ora la mia funzione toHex sembra vedere se è già lì e se lo è - restituisce semplicemente la stringa che gli è stata inviata. Altrimenti, converte la stringa, il numero, qualunque cosa. Ecco la funzione toHex rivista:

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

Questa è una funzione molto veloce che tiene conto di singole cifre, numeri in virgola mobile e persino controlla se la persona sta inviando un valore esadecimale per essere nuovamente esadecimale. Utilizza solo quattro chiamate di funzione e solo due di queste sono nel loop. Per annullare l'esadecimale dei valori utilizzati:

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

Come la funzione toHex (), la funzione fromHex () cerca prima lo "0x" e poi traduce le informazioni in arrivo in una stringa se non è già una stringa. Non so come non sarebbe una stringa - ma per ogni evenienza - controllo. La funzione quindi passa, prendendo due caratteri e traducendoli in caratteri ASCII. Se vuoi che traduca Unicode, dovrai cambiare il ciclo in modo che passi da quattro (4) caratteri alla volta. Ma allora devi anche assicurarti che la stringa NON sia divisibile per quattro. Se lo è, allora è una stringa esadecimale standard. (Ricorda che la stringa ha "0x" sul davanti.)

Un semplice script di test per mostrare che -3.14159265, quando convertito in una stringa, è ancora -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;

?>

A causa del modo in cui JavaScript funziona rispetto alla funzione toString (), è possibile eliminare tutti quei problemi che prima causavano problemi. Ora tutte le stringhe e i numeri possono essere convertiti facilmente. Inoltre, cose come gli oggetti causeranno un errore generato da JavaScript stesso. Credo che questo sia buono come si arriva. L'unico miglioramento rimasto è che W3C includa solo una funzione toHex () e fromHex () in JavaScript.

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

Il 16 è il radix e ci sono 16 valori in un numero esadecimale :-)

Per chiunque sia interessato, ecco un JSFiddle che confronta la maggior parte delle risposte fornite a questa domanda .

Ed ecco il metodo con cui sono finito:

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

Inoltre, tieni presente che se stai cercando di convertire da decimale a esadecimale per l'uso in CSS come tipo di dati a colori , potresti invece preferire estrarre i valori RGB dal decimale e utilizzare rgb () .

Ad esempio ( 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 + ')')

Questo imposta #some-elementla colorproprietà CSS su rgb(64, 62, 154).

Vincolato / imbottito a un determinato numero di caratteri:

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

Ecco una versione ridotta di 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'

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
}

Se vuoi convertire un numero in una rappresentazione esadecimale di un valore di colore RGBA, ho trovato che questa è la combinazione più utile di diversi suggerimenti da qui:

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

Il commento AFAIK 57807 è sbagliato e dovrebbe essere simile a: var hex = Number (d) .toString (16); invece di 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;
}

E se il numero è negativo?

Ecco la mia versione

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

Sto eseguendo la conversione in stringa esadecimale in un ciclo piuttosto grande, quindi ho provato diverse tecniche per trovare quella più veloce. Di conseguenza, i miei requisiti erano avere una stringa di lunghezza fissa e codificare correttamente i valori negativi (-1 => ff..f).

Semplice .toString(16)non ha funzionato per me poiché avevo bisogno di valori negativi per essere codificato correttamente. Il seguente codice è il più veloce che ho testato finora su valori di 1-2 byte (nota che symbolsdefinisce il numero di simboli di output che vuoi ottenere, ovvero per intero a 4 byte dovrebbe essere uguale a 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;
}

Funziona più velocemente rispetto .toString(16)ai numeri di 1-2 byte e più lentamente sui numeri più grandi (quando symbols> = 6), ma dovrebbe comunque superare i metodi che codificano correttamente i valori negativi.

Come afferma la risposta accettata, il modo più semplice per convertire da decimale a esadecimale è var hex = dec.toString(16). Tuttavia, potresti preferire aggiungere una conversione di stringa, in quanto garantisce che le rappresentazioni di stringa come "12".toString(16)funzionino correttamente.

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

Per invertire il processo puoi anche utilizzare la soluzione di seguito, poiché è ancora più breve.

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

Sembra essere più lento in Google Chrome e Firefox, ma è significativamente più veloce in Opera. Vedi http://jsperf.com/hex-to-dec .

Come convertire i decimali in esadecimali in JavaScript

Non sono riuscito a trovare una conversione da decimale brutalmente pulito / semplice in esadecimale che non ha comportato un pasticcio di funzioni e array ... quindi ho dovuto farlo da solo.

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

Per riassumere tutto;

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

Tuttavia, se non è necessario convertirlo nuovamente in un numero intero alla fine (ad esempio per i colori), è sufficiente assicurarsi che i valori non siano negativi.

Non ho trovato una risposta chiara, senza controlli se è negativa o positiva, che utilizza il complemento a due (numeri negativi inclusi). Per questo, mostro la mia soluzione a un byte:

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

È possibile utilizzare questa istruzione per qualsiasi numero byte, solo si aggiunge FFnelle rispettive posizioni. Ad esempio, a due byte:

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

Se si desidera eseguire il cast di un numero intero di array per la stringa esadecimale:

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

Nel caso in cui desideri convertire in una rappresentazione JavaScript o CSS "completa", puoi utilizzare qualcosa come:

  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

Puoi fare qualcosa del genere in ECMAScript 6 :

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

Se stai cercando la conversione di numeri interi grandi, ovvero numeri maggiori di Number.MAX_SAFE_INTEGER - 9007199254740991, puoi utilizzare il seguente codice

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

Questo si basa sulle soluzioni di Prestaul e Tod. Tuttavia, questa è una generalizzazione che tiene conto delle dimensioni variabili di una variabile (ad es. Analisi del valore firmato da un registro seriale del microcontrollore).

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

Script di prova:

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

Risultati del test:

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'

Nota: non sono troppo sicuro del perché non superi i 32 bit

Ecco la mia soluzione:

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

La domanda dice: "Come convertire i decimali in esadecimali in JavaScript" . Mentre, la domanda non specifica che la stringa esadecimale dovrebbe iniziare con un prefisso 0x, chiunque scriva codice dovrebbe sapere che 0x viene aggiunto ai codici esadecimali per distinguere i codici esadecimali da identificatori programmatici e altri numeri (1234 potrebbe essere esadecimale, decimale o anche ottale).

Pertanto, per rispondere correttamente a questa domanda, ai fini della scrittura di script, è necessario aggiungere il prefisso 0x.

La funzione Math.abs (N) converte i negativi in ​​positivi e, come bonus, non sembra che qualcuno lo abbia fatto passare attraverso una cippatrice.

La risposta che volevo avrebbe avuto un identificatore di ampiezza di campo, quindi potremmo ad esempio mostrare i valori 8/16/32/64 bit come li vedresti elencati in un'applicazione di modifica esadecimale. Questa è la risposta effettiva e corretta.