Cómo convertir decimal a hexadecimal en JavaScript
https://stackoverflow.com/questions/57803
-
09-06-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianPregunta
¿Cómo se convierten valores decimales a su equivalente hexadecimal en JavaScript?
Solución
Convierta un número a una cadena hexadecimal con:
hexString = yourNumber.toString(16);
Y revertir el proceso con:
yourNumber = parseInt(hexString, 16);
Otros consejos
Si necesita manejar cosas como campos de bits o colores de 32 bits, entonces necesita manejar números con signo.La función JavaScript toString(16) devolverá un número hexadecimal negativo que normalmente no es el que desea.Esta función realiza algunas sumas locas para convertirlo en 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));El siguiente código convertirá el valor decimal d a hexadecimal.También le permite agregar relleno al resultado hexadecimal.Entonces 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;
}
function toHex(d) {
return ("0"+(Number(d).toString(16))).slice(-2).toUpperCase()
}
Con relleno:
function dec2hex(i) {
return (i+0x10000).toString(16).substr(-4).toUpperCase();
}
Para finalizar, si desea el complemento a dos representación hexadecimal de un número negativo, puede utilizar el desplazamiento de relleno cero a la derecha >>> operador.Por ejemplo:
> (-1).toString(16)
"-1"
> ((-2)>>>0).toString(16)
"fffffffe"
Sin embargo, existe una limitación: Los operadores bit a bit de JavaScript tratan sus operandos como una secuencia de 32 bits, es decir, obtienes el complemento a dos de 32 bits.
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 utilizar pruebas de bucle que deban 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++){}
Combinando algunas de estas buenas ideas para una función de valor RGB a hexadecimal (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);
}
La respuesta aceptada no tuvo en cuenta los códigos hexadecimales devueltos de un solo dígito.Esto se ajusta fácilmente mediante:
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 numerosas veces por otras personas de una forma u otra.Los envuelvo 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 expresiones regulares de JavaScript para mejorar la eficiencia de sus aplicaciones web.
Actualizar:Después de probar esto varias veces encontré un error (comillas dobles en RegExp), así que lo solucioné.¡SIN EMBARGO!Después de algunas pruebas y de haber leído la publicación de almaz, me di cuenta de que no podía hacer que los números negativos funcionaran.
Además, leí un poco sobre esto y, dado que 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 pones "3.14159265" COMO NÚMERO en una variable, todo lo que podrás obtener es el "3", porque solo se puede acceder a la porción fraccionaria multiplicando el número por diez (IE:10.0) repetidamente.O dicho de otro modo: el hexadecimal El valor de 0xF hace que punto flotante valor a traducir a un entero antes de que se le aplique AND, lo que elimina todo lo que está detrás del punto.En lugar de tomar el valor como un todo (es decir:3.14159265) y ANDando el punto flotante valor contra el valor 0xF.
Entonces, lo mejor que se puede hacer, en este caso, es convertir el 3.14159265 en un cadena y luego simplemente convierte la cadena.Debido a lo anterior, también facilita la conversión de números negativos porque el signo menos simplemente se convierte en 0x26 al frente del valor.
Entonces, lo que hice fue determinar que la variable contiene un número: simplemente convertirla en una cadena y convertir la cadena.Esto significa para todos que en el lado del servidor necesitará desenhebrar 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 una "A" al frente de una cadena de caracteres que regresa.Vea la función toHex().
¡Divertirse!
Después de otro año y de pensar mucho, 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 hexadecimal a/desde hexadecimal no debería importarle si algo es una parte fraccional, pero al mismo tiempo debe asegurarse de que las piezas fraccionales se incluyan en la cadena.
Entonces la pregunta fue: "¿Cómo sabes que estás trabajando con una cadena hexadecimal?".La respuesta es simple.Utilice la información estándar previa a la cadena que ya es reconocida en todo el mundo.
En otras palabras, utilice "0x".Entonces, ahora mi función toHex busca ver si eso ya está allí y, si lo está, simplemente devuelve la cadena que se le envió.De lo contrario, convierte la cadena, número, lo que sea.Aquí está la función toHex revisada://///////////////////////////////////////////// /////////////////////// // toHex ().Convierte una cadena ASCII a hexadecimal./////////////////////////////////////////////// ///////////////////////////////// tohex (s) {if (s.substr (0,2) .tolowercase () == "0x ") { devoluciones;}
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 tiene en cuenta dígitos únicos, números de punto flotante e incluso verifica si la persona está enviando un valor hexadecimal para volver a ser hexadecimal.Solo utiliza cuatro llamadas a funciones y solo dos de ellas están en el bucle.Para deshexar los valores que utiliza:
/////////////////////////////////////////////////////////////////////////////
// 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 a una cadena si aún no lo es.No sé cómo no sería una cadena, pero por si acaso, lo compruebo.Luego, la función continúa, toma dos caracteres y los traduce a caracteres ASCII.Si desea que traduzca Unicode, deberá cambiar el bucle para que funcione con cuatro (4) caracteres a la vez.Pero también debes asegurarte de que la cadena NO sea divisible por cuatro.Si es así, entonces es una cadena hexadecimal estándar.(Recuerde que la cadena tiene "0x" al frente).
Un script de prueba simple para mostrar que -3.14159265, cuando se convierte en 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 antes causaban problemas.Ahora todas las cadenas y números se pueden convertir fácilmente.Además, elementos como los objetos provocarán que el propio JavaScript genere un error.Creo que esto es lo mejor que hay.La única mejora que queda es que el W3C incluya simplemente una función toHex() y fromHex() en JavaScript.
var number = 3200;
var hexString = number.toString(16);
El 16 es la base y hay 16 valores en un número hexadecimal :-)
Restringido/rellenado a un número determinado 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
}
Si desea convertir un número a una representación hexadecimal de un valor de color RGBA, he descubierto 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);
}
hasta donde se comentario 57807 está mal y debería ser algo como:var hexadecimal = Número(d).toString(16);en lugar devar hexadecimal = 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 cualquiera interesado, Aquí hay un JSFiddle que compara la mayoría de las respuestas dadas a esta pregunta..
Y este es el método con el que terminé:
function decToHex(dec) {
return (dec + Math.pow(16, 6)).toString(16).substr(-6);
}
Además, tenga en cuenta que si desea convertir de decimal a hexadecimal para usarlo en CSS como tipo de datos de color, es posible que prefieras 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 #some-elementCSS de color propiedad a rgb(64, 62, 154).
Aquí hay una versión recortada de 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'
¿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);
}
Puedes comprobar lo siguiente Ejemplo de JsFiddle o también código de ejemplo de JavaScript de Stack Overflow.
'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'Estoy realizando la conversión a una cadena hexadecimal en un bucle bastante grande, así que probé varias técnicas para encontrar la más rápida.Mis requisitos eran tener como resultado una cadena de longitud fija y codificar los valores negativos correctamente (-1 => ff..f).
Simple .toString(16) no funcionó para mí porque necesitaba que los valores negativos estuvieran codificados correctamente.El siguiente código es el más rápido que he probado hasta ahora en valores de 1 a 2 bytes (tenga en cuenta que symbols define el número de símbolos de salida que desea obtener, es decir, para un entero de 4 bytes 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 symbols >= 6), pero aún así debería superar a los métodos que codifican valores negativos correctamente.
Como dice la respuesta aceptada, la forma más fácil de convertir de decimal a hexadecimal es var hex = dec.toString(16).Sin embargo, es posible que prefieras agregar una conversión de cadena, ya que garantiza que las representaciones de cadena como "12".toString(16) funcionar correctamente.
// Avoids a hard-to-track-down bug by returning `c` instead of `12`
(+"12").toString(16);
Para revertir el proceso también puedes utilizar la solución siguiente, ya que es aún más corta.
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.
Cómo convertir decimal a hexadecimal en JavaScript
No pude encontrar una conversión de decimal a hexadecimal brutalmente limpia/simple que no involucrara un lío de funciones y matrices...así que tuve que hacer esto por mí mismo.
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 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 a un número entero al final (es decir,para los colores), entonces debería ser suficiente asegurarse de que los valores no sean negativos.
No he encontrado una respuesta clara, sin comprobar si es negativa o positiva, que utilice el complemento a dos (incluidos los números negativos).Para eso, muestro mi solución en un byte:
((0xFF + number +1) & 0x0FF).toString(16);
Puede usar esta instrucción para cualquier número de bytes, solo agregue FF en los respectivos lugares.Por ejemplo, a dos bytes:
((0xFFFF + number +1) & 0x0FFFF).toString(16);
Si desea convertir un número entero de matriz a una cadena hexadecimal:
s = "";
for(var i = 0; i < arrayNumber.length; ++i) {
s += ((0xFF + arrayNumber[i] +1) & 0x0FF).toString(16);
}
En caso de que esté buscando convertir a una representación JavaScript o CSS "completa", puede 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
Puedes hacer algo como esto en ECMAScript 6:
const toHex = num => (num).toString(16).toUpperCase();
Si está buscando convertir números enteros grandes, es decirNúmeros mayores que Number.MAX_SAFE_INTEGER - 9007199254740991, entonces puedes usar el siguiente código
const hugeNumber = "9007199254740991873839" // Make sure its in String
const hexOfHugeNumber = BigInt(hugeNumber).toString(16);
console.log(hexOfHugeNumber)Aquí está mi solución:
hex = function(number) {
return '0x' + Math.abs(number).toString(16);
}
La pregunta dice: "Cómo convertir decimal a hexadecimal en JavaScript".Si bien la pregunta no especifica que la cadena hexadecimal debe comenzar con un prefijo 0x, cualquiera que escriba código debe saber que 0x se agrega a los códigos hexadecimales para distinguirlos. códigos hexadecimales de identificadores programáticos y otros números (1234 podría ser hexadecimal, decimal o incluso octal).
Por lo tanto, para responder correctamente a esta pregunta, a efectos de escritura de guiones, debe agregar el prefijo 0x.
La función Math.abs(N) convierte negativos en positivos y, como beneficio adicional, no parece que alguien la haya pasado por una trituradora de madera.
La respuesta que quería habría tenido un especificador de ancho de campo, por lo que podríamos, por ejemplo, mostrar valores de 8/16/32/64 bits de la misma manera que los vería listados en una aplicación de edición hexadecimal.Esa es la respuesta real y correcta.
