Como converter decimal em hexadecimal em JavaScript
https://stackoverflow.com/questions/57803
-
09-06-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianPergunta
Como você converte valores decimais em seu equivalente hexadecimal em JavaScript?
Solução
Converta um número em uma string hexadecimal com:
hexString = yourNumber.toString(16);
E inverta o processo com:
yourNumber = parseInt(hexString, 16);
Outras dicas
Se você precisar lidar com coisas como campos de bits ou cores de 32 bits, precisará lidar com números assinados.A função JavaScript toString(16) retornará um número hexadecimal negativo que geralmente não é o que você deseja.Esta função faz algumas adições malucas 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.Portanto, 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 completar, se você quiser o complemento de dois representação hexadecimal de um número negativo, você pode usar o deslocamento para a direita com preenchimento zero >>> operador.Por exemplo:
> (-1).toString(16)
"-1"
> ((-2)>>>0).toString(16)
"fffffffe"
No entanto, há 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 dois de 32 bits.
Sem o laço:
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
Além disso, 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 ideias para uma função de valor RGB para hexadecimal (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 consideração códigos hexadecimais retornados de 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<s.length; i++) {
a = a + numHex(s.charCodeAt(i));
}
return a;
}
Acredito que as respostas acima foram postadas inúmeras vezes por outras pessoas, de uma forma ou de outra.Eu os envolvo em uma função 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 úteis de expressão regular em JavaScript para melhorar a eficiência de seus aplicativos da web.
Atualizar:Depois de testar isso várias vezes, encontrei um erro (aspas duplas no RegExp), então corrigi isso.NO ENTANTO!Depois de alguns testes e de ler o post de almaz, percebi que não conseguia fazer com que os números negativos funcionassem.
Além disso - li algumas coisas sobre isso e, como todos os números JavaScript são armazenados como palavras de 64 bits, não importa o que aconteça - 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" COMO NÚMERO em uma variável - tudo o que você conseguirá obter é o "3", porque a parte fracionária só é acessível multiplicando o número por dez (IE: 10.0) repetidamente.Ou, dito de outra forma - o hexadecimal valor de 0xF faz com que o ponto flutuante valor a ser traduzido em um inteiro antes de ser AND, o que remove tudo atrás do ponto final.Em vez de considerar o valor como um todo (ou seja:3.14159265) e ANDando o ponto flutuante valor em relação ao valor 0xF.
Então a melhor coisa a fazer, neste caso, é converter o 3,14159265 em um corda e depois é só converter a string.Por causa do acima exposto, também facilita a conversão de números negativos porque o sinal de menos torna-se 0x26 na frente do valor.
Então o que fiz foi determinar que a variável contém um número - basta convertê-la em uma string e converter a string.Isso significa para todos que, no lado do servidor, você precisará remover o hexágono da string recebida e, em seguida, determinar se as informações recebidas são numéricas.Você pode fazer isso facilmente adicionando um “#” na frente dos números e “A” na frente de uma sequência de caracteres que volta.Veja a função toHex().
Divirta-se!
Depois de mais um ano e muita reflexão, decidi que a função "toHex" (e também tenho uma função "fromHex") realmente precisava ser reformulada.Toda a questão era "Como posso fazer isso com mais eficiência?" Decidi que uma função hexadecimal não deveria se importar se algo for uma parte fracionária, mas ao mesmo tempo deve garantir que as peças fracionárias estejam incluídas na string.
Então a pergunta passou a ser: "Como você sabe que está trabalhando com uma string hexadecimal?".A resposta é simples.Use as informações padrão de pré-string que já são reconhecidas em todo o mundo.
Em outras palavras - use "0x".Então agora minha função toHex procura ver se isso já está lá e se está - ela apenas retorna a string que foi enviada para ela.Caso contrário, ele converte a string, o número, o que for.Aqui está a função toHex revisada://///////////////////////////////////////////////////////Tipos ///////////////////////////// TOHEX ().Converta uma string ASCII em hexadecimal./////////////////////////////////////////////////////////Tipos /////////////////////////// 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;
}
Esta é uma função muito rápida que leva em consideração dígitos únicos, números de ponto flutuante e até verifica se a pessoa está enviando um valor hexadecimal para ser hexadecimal novamente.Ele usa apenas quatro chamadas de função e apenas duas delas estão no loop.Para remover o hexadecimal dos 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<s.length; i+=2) {
var c = s.substr(i, 2);
o = o + String.fromCharCode(parseInt(c, 16));
}
return o;
}
Assim como a função toHex(), a função fromHex() primeiro procura o “0x” e depois traduz as informações recebidas em uma string, se ainda não for uma string.Não sei como não seria uma string - mas por precaução - eu verifico.A função então passa, pegando dois caracteres e traduzindo-os em caracteres ASCII.Se quiser traduzir Unicode, você precisará alterar o loop para quatro (4) caracteres por 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 de que a string tem “0x” na frente.)
Um script de teste simples para mostrar que -3,14159265, quando convertido em uma string, ainda é -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;
?>
Devido à forma como o JavaScript funciona em relação à função toString(), todos os problemas que antes estavam causando problemas podem ser eliminados.Agora todas as strings e números podem ser convertidos facilmente.Além disso, coisas como objetos causarão um erro gerado pelo próprio JavaScript.Eu acredito que isso é o melhor que pode acontecer.A única melhoria que resta é que o W3C inclua apenas uma função toHex() e fromHex() em JavaScript.
var number = 3200;
var hexString = number.toString(16);
O 16 é a raiz e existem 16 valores em um número hexadecimal :-)
Restrito/preenchido para um determinado número de caracteres:
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 você deseja converter um número em uma representação hexadecimal de um valor de cor RGBA, descobri que esta é 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);
}
Até onde sei comente 57807 está errado e deveria ser algo como:var hex = Número(d).toString(16);em vez devar 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 quem estiver interessado, aqui está um JSFiddle comparando a maioria das respostas dadas a esta pergunta.
E aqui está o método que acabei usando:
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 para hexadecimal para uso em CSS como um tipo de dados de cor, você pode preferir 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 #some-elementCSS do color propriedade para rgb(64, 62, 154).
Aqui está uma versão reduzida do 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'
E se o número for negativo?
Aqui está 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ê pode verificar o seguinte Exemplo JsFiddle ou código de exemplo JavaScript Stack Overflow também.
'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'Estou fazendo a conversão para string hexadecimal em um loop bem grande, então tentei várias técnicas para encontrar a mais rápida.Como resultado, meus requisitos eram ter uma string de comprimento fixo e codificar valores negativos corretamente (-1 => ff..f).
Simples .toString(16) não funcionou para mim, pois precisava que valores negativos fossem codificados corretamente.O código a seguir é o mais rápido que testei até agora em valores de 1 a 2 bytes (observe que symbols define o número de símbolos de saída que você deseja obter, ou seja, para números inteiros 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 do que .toString(16) em números de 1-2 bytes e mais lento em números maiores (quando symbols >= 6), mas ainda deve superar os métodos que codificam valores negativos adequadamente.
Como afirma a resposta aceita, a maneira mais fácil de converter de decimal para hexadecimal é var hex = dec.toString(16).No entanto, você pode preferir adicionar uma conversão de string, pois garante que representações de string como "12".toString(16) funcionar 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 é ainda mais curta.
var dec = +("0x" + hex);
Parece ser mais lento no Google Chrome e no Firefox, mas é significativamente mais rápido no Opera.Ver http://jsperf.com/hex-to-dec.
Como converter decimal em hexadecimal em JavaScript
Não consegui encontrar uma conversão brutalmente limpa/simples de decimal para hexadecimal que não envolvesse uma confusão de funções e matrizes ...então eu tive que fazer isso sozinho.
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
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 novamente para um número inteiro no final (ou seja,para cores), basta garantir que os valores não sejam negativos.
Não encontrei uma resposta clara, sem verificar se é negativa ou positiva, que utilize complemento de dois (incluindo números negativos).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 adicione FF nos respectivos locais.Por exemplo, para dois bytes:
((0xFFFF + number +1) & 0x0FFFF).toString(16);
Se você quiser converter um array inteiro em string hexadecimal:
s = "";
for(var i = 0; i < arrayNumber.length; ++i) {
s += ((0xFF + arrayNumber[i] +1) & 0x0FF).toString(16);
}
Caso queira converter para uma representação JavaScript 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
Você pode fazer algo assim em ECMAScript 6:
const toHex = num => (num).toString(16).toUpperCase();
Se você estiver procurando converter números inteiros grandes, ou seja,Números maiores que Number.MAX_SAFE_INTEGER -- 9007199254740991, então você pode usar o seguinte código
const hugeNumber = "9007199254740991873839" // Make sure its in String
const hexOfHugeNumber = BigInt(hugeNumber).toString(16);
console.log(hexOfHugeNumber)Aqui está minha solução:
hex = function(number) {
return '0x' + Math.abs(number).toString(16);
}
A pergunta diz: "Como converter decimal em hexadecimal em JavaScript".Embora a pergunta não especifique que a string hexadecimal deva começar com um prefixo 0x, qualquer pessoa que escreva código deve saber que 0x é adicionado aos códigos hexadecimais para distinguir códigos hexadecimais de identificadores programáticos e outros números (1234 pode ser hexadecimal, decimal ou mesmo octal).
Portanto, para responder corretamente a esta pergunta, para fins de escrita de script, você deve adicionar o prefixo 0x.
A função Math.abs(N) converte negativos em positivos e, como bônus, não parece que alguém passou por um picador de madeira.
A resposta que eu queria teria um especificador de largura de campo, para que pudéssemos, por exemplo, mostrar valores de 8/16/32/64 bits da maneira que você os veria listados em um aplicativo de edição hexadecimal.Essa é a resposta real e correta.
