Formattazione del numero esadecimale in Javascript

Question

Ho un numero esadecimale in javascript. Per scopi di visualizzazione, vorrei formattare la stringa come:

ffffffff-ffff-ffff 
00000000-0000-01ff 

(8 cifre) - (4 cifre) - (4 cifre) con zeri imbottite sul fronte

Ho cercato di scrivere il mio loop per formattare un numero esadecimale arbitrario in questo formato, ma questo sembra qualcosa che dovrebbe essere già disponibile in javascript. C'è un modo integrato per formattare un numero esadecimale in javascript?

Grazie!

Answer 1

vorrei fare un processo in due fasi:

1) convertire numero a 16 cifre esadecimale con zeri:

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

2) aggiungere trattini

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

Answer 2

non credo che ci sia qualcosa legata a quella in puro JavaScript, ma quadri fornisco questo metodo, in ExtJS 3 è implementato in questo modo

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

seguito alla risposta del knabar:

Se il numero è davvero un pieno di 64 bit tempo si deve essere consapevoli che Javascript deve solo raddoppia, che uscita superiore a circa 53 bit di precisione. Per esempio.

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

quindi probabilmente vogliono dividere questo in due numeri a 32 bit, e formattare le 8 cifre alla volta. Quindi la seconda avvertenza avverte: javascript esegue operazioni bit a bit su con numeri interi a 32 bit firmati e questo codice di formattazione non può gestire numeri negativi.

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

Dal momento che è abbastanza probabile che i numeri si desidera formattato in esadecimale sono il risultato di manipolazioni bit per bit, il codice può essere ottimizzato per la stampa in complemento a due, invece:

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

questo produce la rappresentazione esadecimale di i 32 bit inferiori della parte integrale di numeri arbitrari positivi e negativi. Questo è probabilmente quello che vuoi (è approssimativamente lo printf("%08x")). Alcuni altri casi angolo:

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

I presuppongono il numero è già nella forma di una stringa a causa delle limitazioni descritte in risposta hexwab. In caso contrario, avviare il processo inserendolo in una stringa esadecimale di lunghezza arbitraria (denominata str) utilizzando qualsiasi meccanismo appropriato per la propria situazione. Poi:

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

Answer 5

ES6 Versione

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

var hexStr = toPaddedHexString(12345, 16);