Formateo de número hexadecimal en Javascript

Question

Tengo un número hexadecimal en javascript. Para fines de presentación, me gustaría dar formato a la cadena como:

ffffffff-ffff-ffff 
00000000-0000-01ff 

(8 dígitos) - (4 dígitos) - (4 dígitos) con ceros acolchados en la parte frontal

que he estado tratando de escribo mi propio bucle para formatear un número hexadecimal arbitrario en este formato, pero parece algo que ya debería estar disponible en JavaScript. ¿Hay una forma incorporada de formatear un número hexadecimal en javascript?

Gracias!

Answer 1

me gustaría hacer un proceso de dos pasos:

1) convertir número a 16 hex dígitos con ceros a la izquierda:

var i = 12345; // your number 
var h = ("000000000000000" + i.toString(16)).substr(-16); 

2) añadir guiones

var result = h.substr(0, 8)+'-'+h.substr(8,4)+'-'+h.substr(12,4); 

Answer 2

no creo que haya nada relacionado con ese en javascript puro, pero los marcos de proporcionar este método, en ExtJS 3 se implementa esta manera

/** 
    * Pads the left side of a string with a specified character. This is especially useful 
    * for normalizing number and date strings. Example usage: 
    * <pre><code> 
var s = String.leftPad('123', 5, '0'); 
// s now contains the string: '00123' 
    * </code></pre> 
    * @param {String} string The original string 
    * @param {Number} size The total length of the output string 
    * @param {String} char (optional) The character with which to pad the original string (defaults to empty string " ") 
    * @return {String} The padded string 
    * @static 
    */ 
    leftPad : function (val, size, ch) { 
     var result = String(val); 
     if(!ch) { 
      ch = " "; 
     } 
     while (result.length < size) { 
      result = ch + result; 
     } 
     return result; 
    } 

Answer 3

con la respuesta de knabar:

Si su número es realmente un total de 64 bits de longitud que debe tener en cuenta que sólo ha Javascript dobles, que alcanzan un máximo de alrededor de 53 bits de precisión. P.ej.

var i = 0x89abcdef; // a 64-bit constant 
var h = ("000000000000000" + i.toString(16)).substr(-16); // "89abcdef" 

Así que es probable que desee dividir esto en dos números de 32 bits, y formatearlos de 8 dígitos a la vez. A continuación, aparece la segunda advertencia: javascript realiza operaciones en modo bit en con números enteros de 32 bits, y este código de formato no puede manejar números negativos.

var i = 0xffd2 << 16; // actually negative 
var h = ("0000000" + i.toString(16)).substr(-8); // "0-2e0000" 

Ya que es bastante probable que los números que desea formateado en hexadecimal son el resultado de las manipulaciones a nivel de bits, el código puede ser ajustado para imprimir en complemento a dos en su lugar:

var i = 0xffd2 << 16; // actually negative 
var h = ("0000000" + ((i|0)+4294967296).toString(16)).substr(-8); // "ffd20000" 

Esto produce la representación hexadecimal de los 32 bits inferiores de la parte integral de números arbitrarios positivos y negativos. Esto es probablemente lo que quiere (es aproximadamente printf("%08x")). Algunos casos más esquinas:

var i = 1.5; // non-integers are rounded 
var h = ("0000000" + ((i|0)+4294967296).toString(16)).substr(-8); // "00000001" 

var i = -1.5; // rounding is towards zero 
var h = ("0000000" + ((i|0)+4294967296).toString(16)).substr(-8); // "ffffffff" 

var i = NaN; // not actually a number 
var h = ("0000000" + ((i|0)+4294967296).toString(16)).substr(-8); // "00000000" 

Answer 4

que asumen el número ya bajo la forma de una cadena se debe a las limitaciones descritas en la respuesta de hexwab. Si no es así, comience el proceso metiéndolo en una cadena hexadecimal de longitud arbitraria (llamada str) utilizando el mecanismo apropiado para su situación. Entonces:

(Array(16).join(0) + str).slice(-16).replace(/^.{8}|.{4}(?!$)/g,"$&-"); 

Answer 5

ES6 Versión

function toPaddedHexString(num, len) { 
    str = num.toString(16); 
    return "0".repeat(len - str.length) + str; 
} 

var hexStr = toPaddedHexString(12345, 16);