Pregunta Cómo convertir decimal a hexadecimal en JavaScript?


¿Cómo se convierten los valores decimales a su equivalente hexadecimal en JavaScript?


1184
2017-09-11 22:26


origen


Respuestas:


Convierte un número a una cadena hexadecimal con:

hexString = yourNumber.toString(16);

y revertir el proceso con:

yourNumber = parseInt(hexString, 16);

1988
2017-09-11 22:28



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


119
2018-03-30 16:05



El siguiente código convertirá el valor decimal d en hexadecimal. También le permite agregar relleno al resultado hexadecimal. entonces 0 se convertirá 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;
}

68
2017-09-11 22:29



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

44
2017-11-05 21:08



Con relleno:

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

30
2017-07-13 14:29



Para completar, si quieres el complemento de dos representación hexadecimal de un número negativo, puede usar cambio de cero a la derecha >>> operador. Por ejemplo:

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

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

Sin embargo, hay una limitación: Los operadores bit a bit de javascript tratan sus operandos como una secuencia de 32 bits, es decir, obtienes el complemento de dos bits de 32 bits.


25
2018-06-14 10:59



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

Además, ¿no 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++){}

16
2017-09-11 03:05



Combinando algunas de estas buenas ideas para una función de rgb a hexadecimal (agrega 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);
}

13
2017-11-15 12:44



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

   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 muchas veces por otros de una forma u otra. Envuelvo esto en una función toHex () así:

   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 útiles de expresión regular de JavaScript para mejorar la eficiencia de las aplicaciones web.

Actualización: Después de probar esto varias veces, encontré un error (comillas dobles en RegExp) así que lo solucioné. ¡SIN EMBARGO! Después de muchas pruebas y de haber leído la publicación de Almaz, me di cuenta de que no podía conseguir que los números negativos funcionaran. Además, hice algunas lecturas sobre esto y dado que todos los números de Javascript están almacenados 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 la porción fraccionaria solo es accesible multiplicando el número por diez (IE: 10.0) repetidamente. O para decirlo de otra manera: el valor HEX de 0xf hace que el valor del PUNTO FLOTANTE se traduzca a INTEGER antes de que se use ANDed, lo que elimina todo lo que hay detrás del período. En lugar de tomar el valor como un todo (es decir, 3.14159265) y anotar el valor del PUNTO FLOTANTE contra el valor 0xf. Entonces, lo mejor que puedes hacer, en este caso, es convertir el 3.14159265 en STRING y luego simplemente convertir la cadena. Debido a lo anterior, también facilita la conversión de números negativos porque el signo menos se convierte en 0x26 en el frente del valor. Entonces, lo que hice fue determinar que la variable contiene un número: simplemente conviértalo en una cadena y conviértalo. Lo que esto significa para todos es que en el lado del servidor necesitará desconectar 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 una 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 era "¿Cómo puedo hacer esto de manera más eficiente?" Decidí que una función hex a / desde no debería importar si algo es una parte fraccionaria, pero al mismo tiempo debería garantizar que las partes fraccionarias se incluyan en la cadena. Entonces, la pregunta fue: "¿Cómo sabe que está trabajando con una cadena hexadecimal?". La respuesta es simple. Use la información previa a la cadena estándar que ya se reconoce en todo el mundo. En otras palabras, use "0x". Así que ahora mi función toHex busca ver si ya está allí y si lo está, simplemente devuelve la cadena que se le envió. De lo contrario, convierte la cadena, el número o lo que sea. Aquí está la función revisada toHex:

/////////////////////////////////////////////////////////////////////////////
//  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 dígitos únicos, números de coma flotante e incluso verifica si la persona está enviando un valor hexadecimal para volver a hexagonal. Solo utiliza cuatro llamadas de función y solo dos de ellas están en el bucle. Para deshelar los valores que 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;
}

Al igual que la función toHex (), la función fromHex () primero busca el "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 las dudas, compruebo. La función se procesa, tomando dos caracteres y traduciéndolos a caracteres ascii. Si quiere que se traduzca unicode, tendrá que cambiar el bucle para ir por cuatro (4) caracteres a la vez. Pero también debes asegurarte de que la cadena NO sea divisible por cuatro. Si lo es, entonces es una cadena hexagonal estándar. (Recuerde que la cadena tiene "0x" en el frente).

Un script de prueba simple para mostrar que -3.14159265, cuando se convierte a una cadena, sigue siendo -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 anteriormente causaban problemas. Ahora todas las cadenas y números se pueden convertir fácilmente. Además, cosas tales como objetos provocarán que el Javascript genere un error. 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.


11
2017-11-06 16:21



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

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


10
2017-09-11 22:32