UUID Decoder

UUID-Struktur

Eine UUID (Universally Unique Identifier) ist ein 128-Bit-Wert, dargestellt als 32 hexadezimale Ziffern, die durch Bindestriche in fünf Gruppen aufgeteilt sind:

Die Version und Variante sind die einzigen zwei Felder, die in jeder UUID garantiert vorhanden sind. Alle anderen Felder hängen von der Version ab.

Das Versionsfeld

Das Versions-Nibble ist die erste Hex-Ziffer der dritten Gruppe (Position 14 im vollständigen String). Es identifiziert, welche UUID-Version zur Generierung des Bezeichners verwendet wurde.

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) ist die neueste weit verbreitete Version, eingeführt in RFC 9562 (2024). Sie kodiert einen Unix-Millisekunden-Zeitstempel in den hohen Bits für Sortierbarkeit.

Das Variantenfeld

Die Variante ist in den hohen Bits des ersten Bytes der vierten Gruppe kodiert. Sie identifiziert die Layout- und Byte-Reihenfolge-Konventionen, die von der UUID verwendet werden.

In der Praxis verwenden nahezu alle UUIDs, denen Sie begegnen, die RFC 4122 / RFC 9562-Variante (Bitmuster 10xx xxxx, erstes Byte der vierten Gruppe im Bereich 0x80–0xBF). Die NCS-, Microsoft COM- und Reserved-Varianten sind Legacy-Formate, die in modernen Systemen selten vorkommen.

UUID-Versionen Referenz

RFC 4122 definierte die Versionen 1–5. RFC 9562 (2024) fügte die Versionen 6, 7 und 8 hinzu:

UUID v1-Zeitstempel dekodieren

UUID v1 enthält einen 60-Bit-Gregorianischen Zeitstempel (100-Nanosekunden-Intervalle seit dem 15. Oktober 1582), der über drei Felder verteilt ist: time_low (Bits 0–31), time_mid (Bits 32–47) und time_hi (Bits 48–59). Dieses Tool setzt sie zusammen und konvertiert sie in ein standardmäßiges 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 sollte als sensibel behandelt werden: Die eingebettete MAC-Adresse und der präzise Zeitstempel können sowohl die generierende Maschine als auch den Zeitpunkt der Generierung identifizieren.

UUID v7-Zeitstempel dekodieren

UUID v7 enthält einen 48-Bit-Unix-Millisekunden-Zeitstempel in den ersten 48 Bits (erste Gruppe + erste 4 Ziffern der zweiten Gruppe). Dieses Tool liest diese Bits und konvertiert sie in ein UTC-Datum mit Millisekunden-Präzision.

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

Im Gegensatz zu UUID v1 verwendet der UUID v7-Zeitstempel die vertraute Unix-Epoche (1. Januar 1970) und enthält keine Host-Informationen. Die restlichen 74 Bits sind zufällig.

Wie dieses Tool UUID-Version und -Variante erkennt

Der Decoder liest Position 14 (Versions-Nibble) und Position 19 (Varianten-Nibble) des kanonischen UUID-Strings. Kein externer Zustand oder Kontext ist erforderlich — alle Informationen sind im UUID-String selbst enthalten.

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

Spezielle UUIDs

Nil UUID

Die Nil-UUID 00000000-0000-0000-0000-000000000000 sind lauter Nullen. Sie ist durch RFC 4122 als Sentinel-Wert definiert, der 'keine UUID' bedeutet — analog zu null. Sie ist keine gültig generierte UUID.

Max UUID

Die Max-UUID ffffffff-ffff-ffff-ffff-ffffffffffff sind lauter Einsen (0xFF in jedem Byte). In RFC 9562 definiert, ist sie das Komplement der Nil-UUID und dient als maximaler Sentinel-Wert.

Häufig gestellte Fragen