UUID Decoder

UUID-struktur

Ett UUID (Universally Unique Identifier) är ett 128-bitarsvärde representerat som 32 hexadecimala siffror uppdelade i fem grupper med bindestreck:

Version och variant är de enda två fälten garanterade att vara närvarande i varje UUID. Alla andra fält beror på versionen.

Versionsfältet

Versionsnibble är den första hexsiffran i den tredje gruppen (position 14 i den fullständiga strängen). Den identifierar vilken UUID-version som användes för att generera identifieraren.

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

Version 7 (UUID v7) är den senaste allmänt använda versionen, introducerad i RFC 9562 (2024). Den kodar en Unix-millisekundtidsstämpel i de höga bitarna för sorterbarhet.

Variantfältet

Varianten kodas i de höga bitarna av den första byten av den fjärde gruppen. Den identifierar layout- och bytordningskonventionerna som används av UUID:t.

I praktiken använder nästan alla UUID du stöter på RFC 4122 / RFC 9562-varianten (bitmönster 10xx xxxx, första byten i den fjärde gruppen i intervallet 0x80–0xBF). NCS-, Microsoft COM- och Reserved-varianterna är äldre format som sällan förekommer i moderna system.

UUID-versionsreferens

RFC 4122 definierade versioner 1–5. RFC 9562 (2024) lade till versioner 6, 7 och 8:

Avkoda UUID v1-tidsstämplar

UUID v1 bäddar in en 60-bitars Gregoriansk tidsstämpel (100-nanosekundintervall sedan den 15 oktober 1582) uppdelad över tre fält: time_low (bitar 0–31), time_mid (bitar 32–47) och time_hi (bitar 48–59). Det här verktyget sätter ihop och konverterar dem till ett standard UTC-datum.

// 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 bör behandlas som känsligt: den inbäddade MAC-adressen och den exakta tidsstämpeln kan identifiera både den genererande maskinen och genereringstiden.

Avkoda UUID v7-tidsstämplar

UUID v7 bäddar in en 48-bitars Unix-millisekundtidsstämpel i de första 48 bitarna (första gruppen + de första 4 siffrorna i den andra gruppen). Det här verktyget läser dessa bitar och konverterar dem till ett UTC-datum med millisekundprecision.

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

Till skillnad från UUID v1 använder UUID v7-tidsstämpeln den bekanta Unix-epoken (1 januari 1970) och bäddar inte in någon värdinformation. De återstående 74 bitarna är slumpmässiga.

Hur det här verktyget identifierar UUID-version och variant

Avkodaren läser position 14 (versionsnibble) och position 19 (variantnibble) i den kanoniska UUID-strängen. Inget externt tillstånd eller kontext behövs — all information är självinnehållande i UUID-strängen.

// 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'
}

Speciella UUID:n

Nil UUID

Nil UUID:t 00000000-0000-0000-0000-000000000000 är alla nollor. Det definieras av RFC 4122 som ett sentinelvärde som betyder 'inget UUID' — analogt med null. Det är inte ett giltigt genererat UUID.

Max UUID

Max UUID:t ffffffff-ffff-ffff-ffff-ffffffffffff är alla ettor (0xFF i varje byte). Definierat i RFC 9562, det är komplementet till nil UUID och fungerar som ett maximalt sentinelvärde.

Vanliga frågor