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 en numerosas ocasiones por otros 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 expresión regular de JavaScript para mejorar la eficiencia de sus 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 probar un poco y haber leído la publicación de almaz, me di cuenta de que no podía obtener números negativos para trabajar.
Además, leí un poco sobre esto y, dado que todos los números de JavaScript se almacenan como palabras de 64 bits, pase lo que pase, 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 fraccional solo es accesible multiplicando el número por diez (IE: 10.0) repetidamente. O para decirlo de otra manera: el valor hexadecimal de 0xF hace que el valor de coma flotante se traduzca a un número entero antes de ser 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 ANDing el punto flotante valor de contra el valor 0xF.
Entonces, lo mejor que 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 se convierte en 0x26 en el frente del valor.
Entonces, lo que hice fue determinar que la variable contiene un número, simplemente convertirlo en una cadena y convertir la cadena. Esto significa para todos que, en el lado del servidor, necesitará eliminar la cadena de entrada 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. Vea la función toHex ().
¡Que te diviertas!
Después de otro año y mucho pensar, 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 to / from 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 previa a la cadena que ya se reconoce en todo el mundo.
En otras palabras, use "0x". Entonces, mi función toHex mira para ver si eso ya está allí y si lo está, solo 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 tiene en cuenta dígitos individuales, números de coma flotante e incluso verifica si la persona está enviando un valor hexadecimal para que se vuelva a hechizar. Solo usa cuatro llamadas a funciones y solo dos de ellas están en el bucle. Para deshechar los valores que usa:
/////////////////////////////////////////////////////////////////////////////
// fromHex(). Convert a hex string to ASCII text.
/////////////////////////////////////////////////////////////////////////////
fromHex(s)
{
var start = 0;
var o = "";
if (s.substr(0,2).toLowerCase() == "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, lo compruebo. Luego, la función se ejecuta, captura dos caracteres y los traduce a caracteres ASCII. Si desea que traduzca Unicode, deberá cambiar el bucle a cuatro (4) caracteres a la vez. Pero también debe asegurarse 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" en la parte delantera).
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, cosas como los objetos provocarán un error generado por el propio JavaScript. Creo que esto es tan bueno como parece. La única mejora que queda es que W3C solo incluya una función toHex () y fromHex () en JavaScript.