Come convertire da decimale a esadecimale in JavaScript

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

Domanda

Come si fa a convertire i valori decimali per il loro equivalente esadecimale in JavaScript?

È stato utile?

Soluzione

Convertire un numero in una stringa esadecimale con:

hexString = yourNumber.toString(16);

E invertire il processo con:

yourNumber = parseInt(hexString, 16);

Altri suggerimenti

Se avete bisogno di gestire le cose come i campi di bit o 32-bit colori, allora avete bisogno di trattare con i numeri con segno.La funzione JavaScript toString(16) tornerà in negativo, numero esadecimale che di solito non è quello che vuoi.Questa funzione fa un po ' folle, oltre a rendere 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 riportato di seguito per convertire il valore decimale d esadecimale.Esso permette anche di aggiungere imbottitura per il risultato esadecimale.Così 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()
}

Con imbottitura:

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

Per il completamento, se si desidera che il in complemento a due la rappresentazione esadecimale di un numero negativo, è possibile utilizzare il zero-fill-shift a destra >>> operatore.Per esempio:

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

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

C'è però una limitazione: JavaScript operatori a livello di bit di trattare i loro operandi come una sequenza di 32 bit, che , a 32-bit in complemento a due.

Senza il loop:

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 il ciclo di test che devono essere valutati?

Per esempio, invece di:

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

sono

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

Combinazione di alcune di queste buone idee per un RGB-valore esadecimale funzione (aggiungere il # altrove (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);
}

Accettato risposta non prendere in considerazione singola cifra restituito i codici esadecimali.Questo è facilmente regolata:

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 sono state pubblicate numerose volte da altri, in una forma o nell'altra.Avvolgere in un toHex() la funzione 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);
    }
}

Nota che il numerico espressione regolare è venuto da 10+ Utile JavaScript Espressione Regolare Funzioni per migliorare le applicazioni web di efficienza.

Aggiornamento:Dopo il test di questa cosa diverse volte, ho trovato un errore (virgolette RegExp), così ho risolto.PERÒ!!!Dopo un po ' di test e, dopo aver letto il post di almaz - ho capito che non potevo ottenere i numeri negativi per il lavoro.

Ulteriormente, ho fatto qualche lettura su questo e da tutti i JavaScript numeri sono memorizzati come 64 bit parole, non importa quello che ho cercato di modificare il numHex codice per ottenere la versione a 64 bit di parola.Ma si scopre che si può fare.Se avete messo "3.14159265" COME UN NUMERO in una variabile - tutto si sarà in grado di ottenere è il "3", perché la parte frazionaria è accessibile solo moltiplicando il numero dieci(IE:10.0) ripetutamente.O mettiamola in un altro modo - il esadecimale valore di 0xF provoca l' in virgola mobile valore di essere tradotta in una integer prima unite mediante un'operazione and, che rimuove tutto il periodo.Piuttosto che prendere il valore intero (es.:3.14159265) e ANDing il in virgola mobile valore contro il 0xF valore.

Quindi la cosa migliore da fare, in questo caso, è quello di convertire il 3.14159265 in un string e poi basta convertire la stringa.A causa di quanto sopra, rende anche più facile per convertire i numeri negativi, perché il segno meno solo diventa 0 x 26, sul fronte del valore.

Quindi quello che ho fatto è stato sulla determinazione che la variabile contiene un numero - basta convertire una stringa e convertire la stringa.Questo vuol dire a tutti che sul lato server è necessario unhex la stringa in ingresso e quindi per determinare le informazioni in arrivo, è di tipo numerico.Si può fare facilmente con la semplice aggiunta di un "#" davanti a numeri e "Un" davanti a una stringa di caratteri di ritorno.Vedere la toHex() funzione.

Buon divertimento!

Dopo un altro anno e un sacco di pensiero, ho deciso che il "toHex" funzione (e anche io ho un "fromHex" funzione) ha realmente bisogno di essere rinnovato.Tutta la domanda era: "Come posso fare questo in modo più efficiente?" Ho deciso che da/esadecimale funzione non dovrebbero preoccuparsi se qualcosa è una parte frazionaria, ma allo stesso tempo, si dovrebbe garantire che le parti frazionarie sono inclusi nella stringa.

Quindi la domanda è diventata, "Come fai a sapere che si sta lavorando con una stringa esadecimale?".La risposta è semplice.Utilizzare lo standard di pre-stringa di informazioni che è già riconosciuto in tutto il mondo.

In altre parole - usare "0x".Così ora il mio toHex funzione cerca per vedere se c'è già e se lo è, semplicemente, che restituisce la stringa è stata inviata.In caso contrario, si converte la stringa, numero, qualunque sia.Qui è rivisto toHex funzione:///////////////////////////////////////////////////////////////////////////// // toHex().Convertire una stringa ASCII in esadecimale.///////////////////////////////////////////////////////////////////////////// toHex(s) { se (s.substr(0,2).toLowerCase() == "0") { 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;
}

Questo è un molto veloce funzione che prende in considerazione solo cifre, numeri in virgola mobile, e anche i controlli per vedere se la persona è l'invio di un valore esadecimale oltre a essere sotto l'effetto di nuovo.Si utilizza solo quattro chiamate di funzione e solo due di questi sono nel loop.Onu-hex i valori che è possibile utilizzare:

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

Come il toHex (), la funzione di fromHex() la funzione cerca prima i "0x" e quindi traduce le informazioni in ingresso in una stringa, se non è già una stringa.Non so come non sarebbe una stringa, ma solo nel caso posso controllare.La funzione passa quindi, afferrare due personaggi e la traduzione di quelle in caratteri ASCII.Se si desidera tradurre Unicode, è necessario modificare il ciclo per andare da quattro(4) caratteri alla volta.Ma è anche necessario assicurarsi che la stringa NON è divisibile per quattro.Se non è - quindi è una stringa esadecimale.(Ricordate che la stringa è "0x" sulla parte anteriore di esso.)

Un semplice script di test per dimostrare 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 di come funziona JavaScript nel rispetto toString (), tutti questi problemi possono essere eliminati che prima stavano causando problemi.Ora tutte le stringhe e numeri possono essere facilmente convertiti.Inoltre, tali cose come oggetti causa di un errore generato da JavaScript.Credo che questo è circa buono come si arriva.L'unico miglioramento di sinistra è per il W3C per includere un toHex() e fromHex() la funzione in JavaScript.

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

Il 16 è la radice e ci sono 16 i valori in un numero esadecimale :-)

Vincolato/imbottita per un determinato numero di caratteri:

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
}

Se si desidera convertire un numero in una rappresentazione esadecimale di un colore RGBA valore, ho trovato questo per essere il più utile combinazione di diversi consigli da qui:

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

AFAIK commento 57807 è sbagliato e dovrebbe essere qualcosa di simile:var hex = Numero di(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;
}

Per chiunque sia interessato, ecco una JSFiddle confrontando la maggior parte delle risposte date a questa domanda.

Ed ecco il metodo che ho finito per andare con:

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

Inoltre, tenete a mente che se si sta cercando di convertire da decimale a esadecimale e per l'uso dei CSS come un colore tipo di dati, si potrebbe invece preferisce estrarre i valori RGB del decimale e l'uso rgb().

Per esempio (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 + ")");

Questo set #some-element's CSS color proprietà rgb(64, 62, 154).

Ecco una tagliata verso il basso ECMAScript 6 versione:

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'

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

È possibile controllare le seguenti JsFiddle esempio o di Overflow dello Stack JavaScript esempio di codice.

'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'

Sto facendo la conversione a stringa esadecimale in un bel ciclo di grandi dimensioni, così ho provato diverse tecniche al fine di trovare il più veloce.Le mie esigenze sono di avere una stringa di lunghezza fissa come risultato, e codificare i valori negativi correttamente (-1 => ff..f).

Semplice .toString(16) non ha funzionato per me in quanto avevo bisogno di valori negativi per essere correttamente codificati.Il codice riportato di seguito è il modo più veloce che ho provato finora 1-2 valori di byte (si noti che symbols definisce il numero di simboli in uscita che si desidera ottenere, che è per intero di 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;
}

Si esegue più velocemente .toString(16) 1-2 byte numeri e più lento su grandi numeri (quando symbols >= 6), ma comunque dovrebbe superare i metodi per codificare i valori negativi correttamente.

Come accettato di rispondere a stati, il modo più semplice per convertire da decimale a esadecimale è var hex = dec.toString(16).Tuttavia, si può scegliere di aggiungere una stringa di conversione, in quanto garantisce che le rappresentazioni di stringa come "12".toString(16) il lavoro correttamente.

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

Per invertire il processo, si può anche utilizzare la soluzione di seguito, come si è ancor di più.

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

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

Come convertire da decimale a esadecimale in JavaScript

Io non sono riuscito a trovare una brutalmente pulire/semplice da decimale a esadecimale conversione che non comportano un casino di funzioni e array ...così ho dovuto fare questo per me.

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 il 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 hai bisogno di convertire un numero intero alla fine (ad es.per i colori), quindi basta fare in modo che i valori non sono negativi, dovrebbe essere sufficiente.

Non ho trovato una risposta chiara, senza controlli se è negativo o positivo, che utilizza in complemento a due (numeri negativi inclusi).Per questo, mi mostra la mia soluzione di un byte:

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

È possibile utilizzare questa istruzione per qualsiasi numero di byte, solo aggiungere FF nei rispettivi luoghi.Per esempio, a due byte:

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

Se si desidera che il cast di un array intero a stringa esadecimale:

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

Nel caso In cui si sta cercando di convertire un 'pieno' di JavaScript o CSS rappresentazione, è possibile 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

Si può fare qualcosa di simile in ECMAScript 6:

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

Se siete alla ricerca per la conversione di Grandi numeri interi, cioèNumeri maggiori di Numero.MAX_SAFE_INTEGER -- 9007199254740991, quindi è possibile utilizzare il codice riportato di seguito

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

Ecco la mia soluzione:

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

La domanda dice: "Come convertire da decimale a esadecimale in JavaScript".Mentre, la domanda non specifica che la stringa esadecimale dovrebbe iniziare con un prefisso 0x, chi scrive il codice deve sapere che 0x è aggiunto per i codici esadecimali per distinguere i codici esadecimali da programmatico identificatori e altri numeri (1234 potrebbe essere esadecimale, decimale, o anche ottale).

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

Il Per La Matematica.abs(N) funzione converte negativi e positivi, e come bonus, non ha l'aspetto di qualcuno che correva in mezzo a un bosco-cippatrice.

La risposta che avrei voluto, avrebbe avuto un campo identificatore di larghezza, in modo da poter, per esempio, mostra 8/16/32/64 bit valori il modo in cui li vedrai in esadecimale applicazione di editing.Che è l'effettiva e corretta risposta.

Autorizzato sotto: CC-BY-SA insieme a attribuzione
Non affiliato a StackOverflow
scroll top