variable - ¿Cómo convertir decimal a hexadecimal en JavaScript?

parseint typescript

Question

¿Cómo convertir valores decimales a su hex equivalente en JavaScript?

Answer 1

¿Y si el número es negativo?

Aquí está mi versión.

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

Answer 2

Combinando algunas de estas buenas ideas para una función rgb a hex (agregue el # en otro 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);
}

Answer 3

Como dice la respuesta aceptada, la forma más fácil de convertir de dec a hexadecimal es var hex = dec.toString(16) . Sin embargo, es posible que prefiera agregar una conversión de cadena, ya que garantiza que las representaciones de cadena como "12".toString(16) funcionen correctamente.

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

Para revertir el proceso, también puede utilizar la solución a continuación, ya que es aún más corto.

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

Parece ser más lento en Google Chrome y Firefox, pero es significativamente más rápido en Opera. Ver http://jsperf.com/hex-to-dec .

Answer 4

Con relleno:

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

Answer 5

Convierte un número en una cadena hexadecimal con:

hexString = yourNumber.toString(16);

y revertir el proceso con:

yourNumber = parseInt(hexString, 16);

Answer 6

El comentario 57807 de AFAIK está equivocado y debería ser algo como: var hex = Number (d) .toString (16); en lugar 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;
}

Answer 7

El siguiente código convertirá el valor decimal d en hexadecimal. También te permite agregar relleno al resultado hexadecimal. por lo que 0 se convertirá en 00 por defecto.

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

Answer 8

En caso de que estés buscando convertirte en una representación JS o CSS "completa", puedes 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

Answer 9

Estoy haciendo la conversión a cadena hexadecimal en un bucle bastante grande, así que probé varias técnicas para encontrar la más rápida. Mis requisitos eran tener una cadena de longitud fija como resultado y codificar los valores negativos correctamente (-1 => ff..f).

Simple .toString(16) no me funcionó porque necesitaba que los valores negativos estuvieran correctamente codificados. El siguiente código es el más rápido que he probado hasta ahora en valores de 1-2 bytes (tenga en cuenta que los symbols definen el número de símbolos de salida que desea obtener, es decir, para un entero de 4 bytes que debe 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;
}

Funciona más rápido que .toString(16) en números de 1-2 bytes y más lento en números más grandes (cuando los symbols > = 6), pero aún así debe superar los métodos que codifican valores negativos correctamente.

Answer 10

La respuesta aceptada no tuvo en cuenta los códigos hexadecimales devueltos de un solo dígito. Esto se ajusta fácilmente por:

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

y

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

Creo que las respuestas anteriores han sido publicadas varias veces por otros de una forma u otra. Envuelvo estos en una función toHex () como tal:

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

Tenga en cuenta que la expresión regular numérica proviene de más de 10 Funciones de expresión regular de JavaScript útiles para mejorar la eficiencia de sus aplicaciones web .

Actualización: Después de probar esto varias veces, encontré un error (comillas dobles en el RegExp), así que lo arreglé. ¡SIN EMBARGO! Después de algunas pruebas y de haber leído el post de almaz, me di cuenta de que no podía hacer funcionar números negativos. Además, hice un poco de lectura sobre esto y como todos los números de Javascript se almacenan como palabras de 64 bits sin importar qué, intenté modificar el código numHex para obtener la palabra de 64 bits. Pero resulta que no puedes hacer eso. Si coloca "3.14159265" COMO NÚMERO en una variable, todo lo que podrá obtener es el "3" porque solo se puede acceder a la parte fraccionaria multiplicando el número por diez (IE: 10.0) repetidamente. O dicho de otra manera: el valor HEX de 0xf hace que el valor del PUNTO DE FLOTACIÓN se traduzca en un INTEGER antes de que sea ANDed, lo que elimina todo lo que está detrás del período. En lugar de tomar el valor como un todo (es decir, 3.14159265) y ANDAR el valor del PUNTO DE FLOTACIÓN contra el valor 0xf. Entonces, lo mejor que se puede hacer, en este caso, es convertir el 3.14159265 en una CADENA y luego simplemente convertir la cadena. Debido a lo anterior, también facilita la conversión de números negativos porque el signo menos solo se convierte en 0x26 en la parte frontal del valor. Entonces, lo que hice fue determinar que la variable contiene un número; simplemente conviértalo en una cadena y convierta la cadena. Lo que esto significa para todos es que, en el lado del servidor, deberá desempañar la cadena entrante y luego determinar que la información entrante es numérica. Puede hacerlo fácilmente simplemente agregando un "#" al frente de los números y "A" al frente de la cadena de caracteres que regresa. Ver la función toHex ().

¡Que te diviertas!

Después de otro año y mucho pensamiento, decidí que la función "toHex" (y también tengo una función "fromHex") realmente necesitaba ser renovada. Toda la pregunta fue "¿Cómo puedo hacer esto de manera más eficiente?" Decidí que a una función hexadecimal desde / hacia no debería importarle si algo es una parte fraccionaria, pero al mismo tiempo debería garantizar que las partes fraccionarias estén incluidas en la cadena. Entonces la pregunta se convirtió en "¿Cómo sabes que estás trabajando con una cadena hexadecimal?". La respuesta es simple. Utilice la información estándar de cadenas previas que ya se reconoce en todo el mundo. En otras palabras, use "0x". Así que ahora mi función toHex mira para ver si ya está allí y si está, simplemente devuelve la cadena que se le envió. De lo contrario, convierte la cadena, el número, lo que sea. Aquí está la función 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<s.length; i++ ){
var c = s.charCodeAt(i);
o = o + l.substr((c>>4),1) + l.substr((c & 0x0f),1);
}
return "0x" + o;
}

Esta es una función muy rápida que toma en cuenta los dígitos únicos, los números de punto flotante e incluso verifica si la persona está enviando un valor hexadecimal nuevamente para ser hexadecimado. Solo utiliza cuatro llamadas de función y solo dos de ellas están en el bucle. Para desexcitar los valores que usas:

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

Al igual que la función toHex (), la función fromHex () primero busca "0x" y luego traduce la información entrante en una cadena si aún no es una cadena. No sé cómo no sería una cadena, pero, por si acaso, lo compruebo. Luego, la función pasa, agarrando dos caracteres y traduciéndolos a caracteres ascii. Si desea que se traduzca en Unicode, deberá cambiar el bucle para que tenga cuatro (4) caracteres a la vez. Pero también debe asegurarse de que la cadena NO se puede dividir por cuatro. Si lo es, entonces es una cadena hexadecimal estándar. (Recuerda que la cadena tiene "0x" en el frente.)

Un script de prueba simple para mostrar que -3.14159265, cuando se convierte en una cadena, aún es -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;
?>

Debido a cómo funciona Javascript con respecto a la función toString (), se pueden eliminar todos esos problemas que antes causaban problemas. Ahora todas las cadenas y números se pueden convertir fácilmente. Además, cosas como los objetos causarán un error que será generado por el propio Javascript. Creo que esto es tan bueno como se pone. La única mejora que queda es que W3C solo incluya una función toHex () y fromHex () en Javascript.

Answer 11

Ok, la respuesta ya se ha dado, esto es gratuito. Aquí hay una versión recortada de ES6:

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

Answer 12

Para completar, si desea que la representación hexadecimal de two''s-complement de un número negativo, puede usar el operador de desplazamiento hacia la derecha con relleno cero >>> . Por ejemplo:

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

Sin embargo, hay una limitación: los operadores bitwise de javascript tratan sus operandos como una secuencia de 32 bits , es decir, se obtiene el complemento a dos de 32 bits.

Answer 13

Para cualquier persona interesada, aquí hay un JSFiddle que compara la mayoría de las respuestas dadas a esta pregunta .

Y aquí está el método con el que terminé yendo:

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

Además, tenga en cuenta que si está buscando convertir de decimal a hexadecimal para usar en CSS como un tipo de datos de color , es posible que prefiera extraer los valores RGB del decimal y usar rgb() .

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

Esto establece la propiedad de color CSS de #some-element en rgb(64, 62, 154) .

Answer 14

Para resumir todo esto;

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

Sin embargo, si no necesita volver a convertirlo en un entero al final (es decir, para los colores), basta con asegurarse de que los valores no sean negativos.

Answer 15

Restringido / rellenado a un número determinado de caracteres:

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

Answer 16

Sé que esta pregunta es antigua, pero no he encontrado una respuesta clara, sin verificaciones si es negativa o positiva, que use el complemento de Dos (números negativos incluidos). Para eso, muestro mi solución a un byte:

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

Puede usar esta instrucción para cualquier número de bytes, solo agregue FF en lugares respectivos. Por ejemplo, a 2 bytes:

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

Si quieres convertir el entero de la matriz a la cadena hex:

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

Lo siento por reactivo un hilo viejo.

Answer 17

Si desea convertir un número en una representación hexadecimal de un valor de color RGBA, he encontrado que esta es la combinación más útil de varios consejos de aquí:

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

Answer 18

Si necesita manejar cosas como campos de bits o colores de 32 bits, entonces necesita tratar con números firmados. La función javascript toString(16) devolverá un número hexadecimal negativo que generalmente no es lo que desea. Esta función hace una adición loca para que sea un 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));

Answer 19

Sin el bucle:

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

Tampoco es mejor no usar pruebas de bucle que deben evaluarse, por ejemplo, en lugar de:

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

tener

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

Answer 20

También puede consultar el siguiente ejemplo de JsFiddle o el código de ejemplo 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''

Answer 21

¿Cómo convertir decimal a hexadecimal en JavaScript?

Sé que esta pregunta es antigua, no pude encontrar una conversión de Dec a Hex brutalmente limpia / simple que no implicara un enredo de funciones y arreglos ... así que tuve que hacer esto por mí mismo. Publicar esto para ayudar a cualquiera que esté buscando esto, sabe que me habría ahorrado algo de tiempo. jajaja

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

Answer 22

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
}

Answer 23

function toHex(d) {
return ("0"+(Number(d).toString(16))).slice(-2).toUpperCase()
}

Answer 24

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

El 16 es el radix y hay 16 valores en un número hexadecimal :-)