Decodificador UUID

Estructura UUID

Un UUID (Identificador Universalmente Único) es un valor de 128 bits representado como 32 dígitos hexadecimales divididos en cinco grupos por guiones:

La versión y la variante son los únicos dos campos garantizados de estar presentes en cada UUID. Todos los demás campos dependen de la versión.

El Campo de Versión

El nibble de versión es el primer dígito hexadecimal del tercer grupo (posición 14 en la cadena completa). Identifica qué versión de UUID se usó para generar el identificador.

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

La versión 7 (UUID v7) es la versión más nueva de uso generalizado, introducida en RFC 9562 (2024). Codifica una marca de tiempo Unix en milisegundos en los bits más significativos para ordenabilidad.

El Campo de Variante

La variante se codifica en los bits más significativos del primer byte del cuarto grupo. Identifica el diseño y las convenciones de orden de bytes usadas por el UUID.

En la práctica, prácticamente todos los UUID que encontrará utilizan la variante RFC 4122 / RFC 9562 (patrón de bits 10xx xxxx, primer byte del cuarto grupo en el rango 0x80–0xBF). Las variantes NCS, Microsoft COM y Reserved son formatos heredados que rara vez se ven en sistemas modernos.

Referencia de Versiones UUID

RFC 4122 definió las versiones 1–5. RFC 9562 (2024) añadió las versiones 6, 7 y 8:

Decodificando Marcas de Tiempo UUID v1

UUID v1 incorpora una marca de tiempo gregoriana de 60 bits (intervalos de 100 nanosegundos desde el 15 de octubre de 1582) distribuida en tres campos: time_low (bits 0–31), time_mid (bits 32–47) y time_hi (bits 48–59). Esta herramienta los reensambla y convierte a una fecha UTC estándar.

// 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 debe tratarse como sensible: la dirección MAC incorporada y la marca de tiempo precisa pueden identificar tanto la máquina generadora como el tiempo de generación.

Decodificando Marcas de Tiempo UUID v7

UUID v7 incorpora una marca de tiempo Unix de 48 bits en milisegundos en los primeros 48 bits (primer grupo + primeros 4 dígitos del segundo grupo). Esta herramienta lee esos bits y los convierte a una fecha UTC con precisión de milisegundos.

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

A diferencia de UUID v1, la marca de tiempo de UUID v7 usa la familiar época Unix (1 de enero de 1970) y no incorpora ninguna información del host. Los 74 bits restantes son aleatorios.

Cómo Esta Herramienta Detecta la Versión y Variante UUID

El decodificador lee la posición 14 (nibble de versión) y la posición 19 (nibble de variante) de la cadena UUID canónica. No se necesita estado externo ni contexto — toda la información está autocontenida en la cadena 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'
}

UUIDs Especiales

UUID Nulo

El UUID nulo 00000000-0000-0000-0000-000000000000 es todo ceros. Está definido por RFC 4122 como valor centinela que significa 'ningún UUID' — análogo a null. No es un UUID generado válido.

UUID Máximo

El UUID máximo ffffffff-ffff-ffff-ffff-ffffffffffff es todo unos (0xFF en cada byte). Definido en RFC 9562, es el complemento del UUID nulo y sirve como valor centinela máximo.

Preguntas Frecuentes