Como converter decimal para hex em JavaScript?

Como você converte valores decimais em seus equivalentes hexadecimais em JavaScript?

Converta um número em uma string hexadecimal com:

hexString = yourNumber.toString(16); 

e inverta o processo com:

 yourNumber = parseInt(hexString, 16); 

Se você precisar lidar com itens como campos de bits ou colors de 32 bits, precisará lidar com números assinados. A function javascript toString(16) retornará um número hexadecimal negativo que normalmente não é o que você deseja. Esta function faz alguma adição louca para torná-lo um número 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)); 

O código abaixo irá converter o valor decimal d em hexadecimal. Também permite adicionar preenchimento ao resultado hexadecimal. então 0 se tornará 00 por padrão.

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

Com preenchimento:

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

Para conclusão, se você quiser a representação hexadecimal de um número negativo em complemento de dois, você pode usar o operador >>> deslocamento de preenchimento à direita . Por exemplo:

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

Há, no entanto, uma limitação: os operadores bit a bit do javascript tratam seus operandos como uma sequência de 32 bits , ou seja, você obtém o complemento de 32 bits de dois bits.

Sem o 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 

Também não é melhor não usar testes de loop que precisam ser avaliados, por exemplo, em vez de:

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

ter

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

Combinando algumas dessas boas idéias para uma function rgb para hex (adicione o # em outro lugar para 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); } 

A resposta aceita não levou em conta os códigos hexadecimais retornados por um único dígito. Isso é facilmente ajustado por:

  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 

Acredito que as respostas acima foram publicadas várias vezes por outras pessoas de uma forma ou de outra. Eu envolvo estes em uma function toHex () assim:

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

Observe que a expressão regular numérica veio de mais de 10 funções de expressões regulares de JavaScript úteis para melhorar a eficiência de seus aplicativos da Web .

Update: Depois de testar essa coisa várias vezes eu encontrei um erro (aspas duplas no RegExp), então eu consertei isso. CONTUDO! Depois de um bom tempo testando e tendo lido o post por almaz - eu percebi que não conseguiria números negativos para funcionar. Além disso - eu fiz alguma leitura sobre isso e desde que todos os números de JavaScript são armazenados como palavras de 64 bits, não importa o que - eu tentei modificar o código numHex para obter a palavra de 64 bits. Mas acontece que você não pode fazer isso. Se você colocar "3.14159265" AS NUMBER em uma variável - tudo o que você será capaz de obter é o "3" porque a porção fracionária só é acessível multiplicando o número por dez (IE: 10.0) repetidamente. Ou, para colocar de outra forma - o valor HEX de 0xf faz com que o valor do PONTO DE FLUTUAÇÃO seja convertido em um INTEGER antes de ser o ANDed, o que remove tudo por trás do período. Em vez de tomar o valor como um todo (ou seja: 3,14159265) e ANDing o valor de PONTO DE FLUTUAÇÃO contra o valor de 0xf. Portanto, a melhor coisa a fazer, neste caso, é converter o 3.14159265 em um STRING e depois converter a string. Por causa do acima, também torna fácil converter números negativos porque o sinal de menos apenas se torna 0x26 na frente do valor. Então, o que eu fiz foi determinar que a variável contém um número - basta convertê-lo em uma string e converter a string. O que isso significa para todos é que no lado do servidor você precisará refazer a seqüência de input e, em seguida, determinar que a informação recebida é numérica. Você pode fazer isso facilmente apenas adicionando um "#" na frente dos números e "A" na frente de uma string de caracteres voltando. Veja a function toHex ().

Diverta-se!

Depois de mais um ano e muita reflection, decidi que a function "toHex" (e também tenho uma function "fromHex") precisava ser renovada. A questão toda era "Como posso fazer isso de forma mais eficiente?" Decidi que uma function hexagonal de / para não deveria se importar se algo fosse uma parte fracionária, mas ao mesmo tempo deveria garantir que partes fracionárias fossem incluídas na string. Então a pergunta foi: "Como você sabe que está trabalhando com uma string hexadecimal?". A resposta é simples. Use as informações padrão pré-string que já são reconhecidas em todo o mundo. Em outras palavras - use "0x". Então agora minha function toHex procura ver se isso já está lá e se está - apenas retorna a string que foi enviada para ele. Caso contrário, ele converte a string, número, o que for. Aqui está a function toHex revisada:

 ///////////////////////////////////////////////////////////////////////////// // 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>4),1) + l.substr((c & 0x0f),1); } return "0x" + o; } 

Esta é uma function muito rápida que leva em conta dígitos únicos, números de ponto flutuante e até verifica se a pessoa está enviando um valor hexadecimal para ser novamente hexadecimal. Ele usa apenas quatro chamadas de function e apenas duas delas estão no loop. Para descompactar os valores que você usa:

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

Como a function toHex (), a function fromHex () primeiro procura pelo "0x" e, em seguida, ele converte as informações recebidas em uma string, se já não for uma string. Eu não sei como não seria uma string - mas apenas no caso - eu confiro. A function então passa, pegando dois caracteres e traduzindo-os para caracteres ascii. Se você quiser traduzir unicode, você precisará alterar o loop para passar por quatro (4) caracteres de cada vez. Mas você também precisa garantir que a string NÃO seja divisível por quatro. Se for, então é uma string hexadecimal padrão. (Lembre-se que a string tem "0x" na frente dela).

Um script de teste simples para mostrar que -3.14159265, quando convertido em uma string, ainda é -3.14159265.

  Test      EOD; ?> 

Por causa de como o Javascript funciona em relação à function toString (), todos esses problemas podem ser eliminados, o que antes estava causando problemas. Agora todas as strings e números podem ser convertidos facilmente. Além disso, coisas como objects causarão um erro a ser gerado pelo próprio Javascript. Eu acredito que isso é tão bom quanto parece. A única melhoria que resta é que o W3C inclua apenas uma function toHex () e fromHex () em Javascript.

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

O 16 é o radical e existem 16 valores em um número hexadecimal 🙂

 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 você quiser converter um número em uma representação hexadecimal de um valor de cor RGBA, descobri que essa é a combinação mais útil de várias dicas daqui:

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

Constrangido / preenchido para um determinado número de caracteres:

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

AFAIK comentário 57807 está errado e deve ser algo como: var hex = Number (d) .toString (16); em vez de 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; } 

Para qualquer pessoa interessada, aqui está um JSFiddle comparando a maioria das respostas dadas a esta questão .

E aqui está o método que acabei indo com:

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

Além disso, tenha em mente que, se você deseja converter de decimal em hexadecimal para uso em CSS como um tipo de dados de cor , talvez prefira extrair os valores RGB do decimal e usar rgb () .

Por exemplo ( 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 + ")"); 

Isso define a propriedade de color CSS de #some-element para rgb(64, 62, 154) .

E se o número for negativo?

Aqui está a minha versão.

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

Você também pode verificar o exemplo JsFiddle a seguir ou o código de exemplo Stackoverflow JS.

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

Eu estou fazendo conversão para hex string em um loop muito grande, então eu tentei várias técnicas para encontrar o mais rápido. Meus requisitos eram para ter uma string de tamanho fixo como resultado e codificar valores negativos corretamente (-1 => ff..f).

Simple .toString(16) não funcionou para mim desde que eu precisei de valores negativos para serem codificados corretamente. O código a seguir é o mais rápido que testei até agora em valores de 1-2 bytes (note que os symbols definem o número de símbolos de saída que você deseja obter, isto é, para o inteiro de 4 bytes deve ser igual 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; } 

Ele executa mais rápido que .toString(16) em números de byte 1-2 e mais lento em números maiores (quando symbols > = 6), mas ainda deve superar methods que codificam valores negativos corretamente.

Como converter decimal para hex em JavaScript?

Eu sei que esta pergunta é antiga, não foi capaz de encontrar uma conversão brutalmente limpa / simples de Dec para Hex que não envolvesse uma confusão de funções e matrizes … então eu tive que fazer isso por mim mesmo. Postar isso para ajudar qualquer um que esteja procurando por isso, saiba que teria me poupado algum tempo. ri muito

 /* Revision: modified coding style, with array instead of a switch. */ function DecToHex( decimal ){ // Data (decimal) length = -1; // Base string length string = ''; // Source 'string' charactor = [ '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' ]; // charactor array do { // grab each nibble in reverse order because javscript has no unsigned left shift string += charactor[ decimal & 0xF ]; // mask byte, get that charactor ++length; // incriment to length of string } while( decimal >>>= 4 ); // for next char 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( hexadecial ); } /* 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 hex equivalent 

Como afirma a resposta aceita, a maneira mais fácil de converter de dec para hexadecimal é var hex = dec.toString(16) . No entanto, você pode preferir adicionar uma conversão de string, pois isso garante que as representações de string como "12".toString(16) funcionem corretamente.

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

Para reverter o processo, você também pode usar a solução abaixo, pois ela é ainda mais curta.

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

Parece ser mais lento no Google Chrome e no Firefox, mas é significativamente mais rápido no Opera. Veja http://jsperf.com/hex-to-dec .

Ok, a resposta já foi dada, isso é gratuito. Aqui está uma versão ES6 aparada:

 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' 

Para resumir tudo;

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

No entanto, se você não precisar convertê-lo de volta para um número inteiro no final (ou seja, para colors), apenas certifique-se de que os valores não sejam negativos deve ser suficiente.

Eu sei que esta pergunta é antiga, mas eu não encontrei uma resposta clara, sem controlos se é negativo ou positivo, que usa o complemento de dois (números negativos incluídos). Para isso, mostro minha solução para um byte:

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

Você pode usar esta instrução para qualquer número de bytes, apenas você adiciona FF nos respectivos lugares. Por exemplo, para 2 bytes:

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

Se você quiser converter inteiro inteiro para cadeia hexadecimal:

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

Desculpe por reativar um segmento antigo.

Caso você queira converter para uma representação JS ou CSS ‘completa’, você pode usar algo como:

  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 
    Intereting Posts