Décodeur UUID

Structure UUID

Un UUID (Universally Unique Identifier) est une valeur de 128 bits représentée sous forme de 32 chiffres hexadécimaux divisés en cinq groupes par des tirets :

La version et la variante sont les deux seuls champs garantis d'être présents dans chaque UUID. Tous les autres champs dépendent de la version.

Le champ de version

Le nibble de version est le premier chiffre hexadécimal du troisième groupe (position 14 dans la chaîne complète). Il identifie la version UUID utilisée pour générer l'identifiant.

const hex = uuid.replace(/-/g, '')
const version = parseInt(hex[12], 16)  // single hex digit → 1, 2, 3, 4, 5, 6, 7, or 8

La version 7 (UUID v7) est la version la plus récente largement utilisée, introduite dans RFC 9562 (2024). Elle encode un horodatage Unix en millisecondes dans les bits de poids fort pour la triabilité.

Le champ de variante

La variante est encodée dans les bits de poids fort du premier octet du quatrième groupe. Elle identifie les conventions de disposition et d'ordre des octets utilisées par l'UUID.

En pratique, la quasi-totalité des UUID que vous rencontrez utilisent la variante RFC 4122 / RFC 9562 (modèle de bits 10xx xxxx, premier octet du quatrième groupe dans la plage 0x80–0xBF). Les variantes NCS, Microsoft COM et Reserved sont des formats hérités rarement rencontrés dans les systèmes modernes.

Référence des versions UUID

RFC 4122 a défini les versions 1-5. RFC 9562 (2024) a ajouté les versions 6, 7 et 8 :

Décodage des horodatages UUID v1

UUID v1 intègre un horodatage grégorien de 60 bits (intervalles de 100 nanosecondes depuis le 15 octobre 1582) réparti sur trois champs : time_low (bits 0-31), time_mid (bits 32-47) et time_hi (bits 48-59). Cet outil les réassemble et les convertit en date UTC standard.

// UUID v1: 6ba7b810-9dad-11d1-80b4-00c04fd430c8
//           ^^^^^^^^ ^^^^ ^^^^ ^^^^^ ^^^^^^^^^^^^
//           time-low  mid  hi  clk   node (MAC)
//                          ^
//                          version nibble (1)

const hex = '6ba7b8109dad11d180b400c04fd430c8'

const tLow = parseInt(hex.slice(0, 8),  16)  // 0x6ba7b810
const tMid = parseInt(hex.slice(8, 12), 16)  // 0x9dad
const tHi  = parseInt(hex.slice(13, 16), 16) // 0x1d1 (skip version nibble at index 12)

// Reconstruct 60-bit timestamp (100-ns intervals since Oct 15, 1582)
const t = (BigInt(tHi) << 48n) | (BigInt(tMid) << 32n) | BigInt(tLow)

// Subtract Gregorian offset (Oct 15, 1582 → Jan 1, 1970 in 100-ns units)
const GREGORIAN_OFFSET = 122192928000000000n
const unixMs = (t - GREGORIAN_OFFSET) / 10000n

console.log(new Date(Number(unixMs)).toISOString())
// → 1998-02-04T22:13:53.578Z

UUID v1 doit être traité comme sensible : l'adresse MAC intégrée et l'horodatage précis peuvent identifier à la fois la machine génératrice et le temps de génération.

Décodage des horodatages UUID v7

UUID v7 intègre un horodatage Unix de 48 bits en millisecondes dans les 48 premiers bits (premier groupe + 4 premiers chiffres du deuxième groupe). Cet outil lit ces bits et les convertit en date UTC avec une précision milliseconde.

// UUID v7: 018e4bc8-1000-7000-8000-000000000001
//           ^^^^^^^^^^^^
//           48-bit Unix ms timestamp

const hex = '018e4bc8100070008000000000000001'

// First 48 bits (12 hex chars) = Unix timestamp in milliseconds
const ms = parseInt(hex.slice(0, 12), 16)  // 0x018e4bc81000

console.log(new Date(ms).toISOString())
// → 2024-03-11T…Z

// Everything after byte 6 is random (except version/variant bits)

Contrairement à UUID v1, l'horodatage UUID v7 utilise l'epoch Unix familier (1er janvier 1970) et n'intègre aucune information sur l'hôte. Les 74 bits restants sont aléatoires.

Comment cet outil détecte la version et la variante UUID

Le décodeur lit la position 14 (nibble de version) et la position 19 (nibble de variante) de la chaîne UUID canonique. Aucun état externe ni contexte n'est nécessaire — toute l'information est contenue dans la chaîne UUID.

// Detect UUID version from the 13th hex character (index 12)
function uuidVersion(uuid) {
  const clean = uuid.replace(/-/g, '')
  return parseInt(clean[12], 16)
}

uuidVersion('550e8400-e29b-41d4-a716-446655440000') // → 4
uuidVersion('018e4bc8-1000-7000-8000-000000000001') // → 7
uuidVersion('6ba7b810-9dad-11d1-80b4-00c04fd430c8') // → 1

// Detect variant from the 17th hex character (index 16, first char of 4th group)
function uuidVariant(uuid) {
  const clean = uuid.replace(/-/g, '')
  const b = parseInt(clean[16], 16)
  if ((b & 0x8) === 0)      return 'NCS'
  if ((b & 0xC) === 0x8)    return 'RFC 4122'
  if ((b & 0xE) === 0xC)    return 'Microsoft'
  return 'Reserved'
}

UUID spéciaux

UUID nil

L'UUID nil 00000000-0000-0000-0000-000000000000 est entièrement à zéro. Il est défini par RFC 4122 comme valeur sentinelle signifiant 'aucun UUID' — analogue à null. Ce n'est pas un UUID généré valide.

UUID max

L'UUID max ffffffff-ffff-ffff-ffff-ffffffffffff est entièrement à un (0xFF dans chaque octet). Défini dans RFC 9562, c'est le complément de l'UUID nil et sert de valeur sentinelle maximale.

Foire Aux Questions