Formatage d'un nombre hexadécimal en UUID court en JavaScript

Question

J'ai un nombre hexadécimal en javascript. Pour des raisons d'affichage, j'aimerais formater la chaîne comme suit :

ffffffff-ffff-ffff
00000000-0000-01ff

(8 digits)-(4 digits)-(4 digits) avec des zéros rembourrés au recto

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é de formater un nombre hexadécimal en JavaScript ?

Answer 1

Je procéderais en deux étapes :

1) convertir le nombre en 16 chiffres hexadécimaux avec des zéros en tête :

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);

Answer 2

En complément de la réponse de knabar :

Si votre nombre a vraiment une longueur de 64 bits, vous devez savoir que javascript n'a que des doubles, qui ont une précision maximale d'environ 53 bits. Par exemple

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

Vous voudrez donc probablement le diviser en deux nombres de 32 bits et les formater 8 chiffres à la fois. C'est alors que survient la deuxième mise en garde : javascript effectue des opérations bit à bit sur signé Les nombres entiers de 32 bits, et ce code de formatage 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 que vous souhaitez voir formatés en hexadécimal soient le résultat de manipulations bit à bit, le code peut être modifié pour imprimer en complément à deux :

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

Cela permet d'obtenir la représentation hexadécimale des 32 bits inférieurs de la partie intégrante des nombres positifs et négatifs arbitraires. C'est probablement ce que vous voulez (c'est approximativement printf("%08x") ). Quelques autres cas de figure :

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 3

Version ES6

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

var hexStr = toPaddedHexString(12345, 16);

Answer 4

Il existe deux méthodes pour String appelé padStart y padEnd

const num = 15;
console.log(num.toString(16).padStart(2, "0")); // "0f"

const num = 15;
console.log(num.toString(16).padEnd(2, "0")); // "f0"

Informations complémentaires sur le lien : padStart , padEnd

Answer 5

La version la plus courte est la suivante

Pour un identifiant tel que 00000000-0000-01ff

Il s'agit d'une version réécrite et abrégée de la réponse d'Adam Leggett.

function createID_8_4_4(s)
{
    return(1e16+s).slice(-16).replace(/^.{8}|.{4}(?!$)/g,'$&-')
    /*
        OR the version for easy understanding:
        return(1e16+s).slice(-16).match(/..../g).join('-').replace('-','')
        replace on the end replaces only first '-'
    */
}

console.log(createID_8_4_4('01ff')); //00000000-0000-01ff

Pour un identifiant tel que 0000-0000-0000-01ff

function createID_4_4_4_4(s)
{
    return(1e16+s).slice(-16).match(/..../g).join('-')
}

console.log(createID_4_4_4_4('01ff')); //0000-0000-0000-01ff