web-dev-qa-db-fra.com

Formatage du nombre hexadécimal en Javascript

J'ai un nombre hexadécimal en javascript. Pour l'affichage, je voudrais formater la chaîne comme suit:

ffffffff-ffff-ffff
00000000-0000-01ff

(8 chiffres) - (4 chiffres) - (4 chiffres) avec des zéros remplis à l'avant

J'ai essayé d'écrire ma propre boucle pour formater un nombre hexadécimal arbitraire dans ce format, mais cela semble être quelque chose qui devrait déjà être disponible en javascript. Existe-t-il un moyen intégré pour formater un nombre hexadécimal en javascript?

Merci!

javascriptformattinghex
17
David

Je ferais un processus en deux étapes:

1) convertir le nombre en hexadécimal à 16 chiffres avec les zéros au début:

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

2) ajouter des tirets

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

Suite à la réponse de Knabar:

Si votre nombre est vraiment de 64 bits, sachez que javascript ne fait que doubler, ce qui correspond à une précision de 53 bits environ. Par exemple.

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

Donc, vous voulez probablement diviser cela en deux nombres de 32 bits et les formater à 8 chiffres à la fois. Ensuite, la deuxième mise en garde s'impose: javascript effectue des opérations au niveau des bits sur les entiers signed 32-bit, et ce code de mise en forme ne peut pas gérer les nombres négatifs.

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

Comme il est assez probable que les nombres au format hexadécimal soient le résultat de manipulations au niveau des bits, vous pouvez modifier le code pour obtenir un complément à deux:

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

Ceci produit la représentation hexadécimale des 32 bits du bas de la partie intégrale des nombres positifs et négatifs arbitraires. C’est probablement ce que vous voulez (c’est environ printf("%08x")). Quelques cas supplémentaires:

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"
13
hexwab

Version ES6 

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

var hexStr = toPaddedHexString(12345, 16);
8
Nilesh

je ne pense pas qu'il y ait quoi que ce soit lié à cela en javascript pur, mais les frameworks fournissent cette méthode, dans ExtJS 3, elle est implémentée de cette façon.

    /**
     * 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;
    }
1
Saket Patel

Je suppose que le nombre est déjà sous la forme d'une chaîne en raison des limitations décrites dans la réponse de hexwab. Si ce n'est pas le cas, démarrez le processus en le mettant dans une chaîne hexagonale de longueur arbitraire (appelée str) en utilisant le mécanisme approprié à votre situation. Ensuite:

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