UUID Generator Online - Generer UUID v1-v7 gratis

Hvad er en UUID?

UUID (Universally Unique Identifier) er en 128-bit identifikator, der bruges i computersystemer til unikt at identificere information. UUID er standardiseret i henhold til RFC 4122, og takket være dens enorme entropi garanterer den en praktisk talt nul sandsynlighed for kollision – hvilket betyder, at to uafhængigt genererede UUID’er næsten helt sikkert vil være unikke.

UUID’er har et standardformat: xxxxxxxx-xxxx-Mxxx-Nxxx-xxxxxxxxxxxx, hvor hvert x er et hexadecimalt ciffer (0-9, a-f), M angiver UUID-versionen, og N angiver varianten.

UUID-versioner

UUID v1 (Tidsstempel + MAC-adresse)

UUID v1 er baseret på et aktuelt tidsstempel og en tilfældig værdi (i browseren i stedet for MAC-adresse). Den bruger 100-nanosekund intervaller fra den 15. oktober 1582 (Gregoriansk kalender).

Anvendelse:

• Situationer hvor du har brug for kronologisk sortering af UUID’er
• Debugging og logning (UUID indeholder information om oprettelsestidspunkt)
• Distribuerede systemer med tidssynkronisering

Eksempel: 6ba7b810-9dad-11d1-80b4-00c04fd430c8

Fordele:

• UUID’er kan sorteres kronologisk efter oprettelsestidspunkt
• Nyttigt til revision og debugging
• Indeholder tidsstempelinformation

Ulemper:

• Potentiel sikkerhedsrisiko – indeholder tidsstempel
• I browseren indeholder den ikke en rigtig MAC-adresse (erstattes af en tilfældig værdi)
• Dårlig DB-lokalitet (tidsstempel er i low-order bits)

UUID v3 (MD5-hash)

UUID v3 genereres ved hjælp af MD5-hash af et namespace UUID og et navn. Deterministisk – samme namespace + navn vil altid skabe den samme UUID.

Anvendelse:

• Konvertering af URL’er, DNS-navne eller andre identifikatorer til UUID’er
• Situationer hvor du har brug for reproducerbare UUID’er
• Mapping mellem forskellige identifikationssystemer

Eksempel: a3bb189e-8bf9-3888-9912-ace4e6543002

Fordele:

• Deterministisk (samme input = samme output)
• Ideel til konvertering af kendte identifikatorer
• Ingen kollision for forskellige inputs

Ulemper:

• MD5 er en forældet algoritme (foretræk v5)
• Kræver namespace og navn
• Kan ikke gendanne originalt input

UUID v4 (Tilfældig) - ANBEFALET

Den mest anvendte UUID-version. UUID v4 genereres rent tilfældigt ved hjælp af en kryptografisk sikker tilfældighedsgenerator (crypto.getRandomValues()).

Anvendelse:

• Primære nøgler i databaser
• Sessions-ID’er
• Unikke filnavne
• API-tokens
• Generelle formål, hvor du har brug for et garanteret unikt ID

Eksempel: f47ac10b-58cc-4372-a567-0e02b2c3d479

Fordele:

• Maksimal entropi og sikkerhed
• Ingen afhængighed af tid eller systemparametre
• Den enkleste implementering

Sandsynlighed for kollision: Ved generering af 1 milliard UUID’er pr. sekund i 100 år er chancen for kollision ca. 0,00000006%.

UUID v5 (SHA-1-hash)

UUID v5 er det samme som v3, men bruger SHA-1 i stedet for MD5. Et mere moderne og sikkert alternativ til v3.

Anvendelse:

• Samme som v3, men med bedre sikkerhed
• Foretrukket frem for v3 til nye projekter
• Generering af UUID fra URL’er, DNS-navne, OID, X.500 DN

Eksempel: 886313e1-3b8a-5372-9b90-0c9aee199e5d

Fordele:

• Deterministisk
• SHA-1 er mere robust end MD5
• Velegnet til mapping mellem systemer

Ulemper:

• SHA-1 betragtes også som forældet (men stadig sikrere end MD5)
• Kræver namespace og navn

UUID v6 (Sorteret tidsstempel)

UUID v6 er en forbedret version af v1 med omarrangerede tidsbits for bedre DB-indeksering. Designet til at løse lokalitetsproblemer i databaser.

Anvendelse:

• Primære nøgler i databaser med tidsbaseret sortering
• Systemer der kræver både kronologisk sortering og DB-ydeevne
• Et mere moderne alternativ til v1

Eksempel: 1ec9414c-232a-6b00-b3c8-9e6bdeced846

Fordele:

• Bedre DB-lokalitet end v1 (tidsstempel i high-order bits)
• Kronologisk sortering
• Kompatibel med UUID-standarden

Ulemper:

• Mindre brugt end v1/v4
• Indeholder stadig tidsinformation (sikkerhedsrisiko)

UUID v7 (Unix-tidsstempel)

UUID v7 bruger Unix-tidsstempel (millisekunder siden 1970) + tilfældige bits. Den nyeste UUID-version med den bedste DB-lokalitet.

Anvendelse:

• Moderne primære nøgler i databaser
• Systemer der kræver ydeevne + tidsbaseret sortering
• Erstatning for v1/v6 i nye projekter

Eksempel: 017f22e2-79b0-7cc3-98c4-dc0c0c07398f

Fordele:

• Bedste DB-lokalitet af alle versioner
• Unix-tidsstempel er standard
• Kombinerer fordelene ved tilfældighed og tidsbaseret sortering

Ulemper:

• Relativt ny specifikation (RFC 4122bis)
• Mindre understøttet i ældre systemer

Hvilken UUID-version skal du bruge?

Beslutningsguide

Har du brug for maksimal sikkerhed og tilfældighed? → Brug UUID v4 (det mest almindelige valg)

Har du brug for tidsbaseret sortering og DB-ydeevne? → Brug UUID v7 (moderne) eller UUID v6 (standard)

Har du brug for reproducerbare UUID’er fra eksisterende identifikatorer? → Brug UUID v5 (SHA-1) eller UUID v3 (MD5, ældre)

Har du brug for et tidsstempel og revisionsspor? → Brug UUID v1 (ældre, dårligere DB-ydeevne)

Databaser

Til nye projekter: UUID v7 eller v4

• v7 er ideel til tidsbaseret sortering + ydeevne
• v4 for maksimal tilfældighed uden tidsinformation

Til ældre systemer: UUID v1 eller v6

• v6 har bedre DB-lokalitet end v1
• v1 er bredt understøttet

Fordele ved UUID som primærnøgle:

• Global unikhed – Du kan forbinde data fra forskellige databaser uden konflikt
• Sikkerhed – I modsætning til sekventielle ID’er (1, 2, 3…) kan næste værdier ikke gættes
• Distribuerede systemer – UUID’er kan genereres uafhængigt på flere servere uden koordinering
• Sammenfletning af databaser – Ved sammenlægning af to databaser opstår der ingen konflikter

Ulemper:

• Større størrelse (16 bytes vs 4-8 bytes for integer)
• Langsommere indeksering i nogle databaser (brug v6/v7 for bedre ydeevne)
• Mindre læselig for mennesker

API og webtjenester

• REST API – Unikke identifikatorer for ressourcer
• GraphQL – Globale identifikatorer for noder
• Webhooks – Sporing af anmodninger og svar
• Tokens – Sessions-ID’er, refresh-tokens

Filer og lagring

• Filnavne – Forebyggelse af kollisioner ved upload
• S3/Cloud Storage – Unikke stier til objekter
• Cache-nøgler – Identifikatorer i cache-systemer

Frontend-applikationer

• React/Vue-komponenter – Unikke nøgler til lister
• Midlertidige ID’er – ID’er før lagring i databasen
• Lokal lagring – Nøgler til gemte data
• Offline-first applikationer – Generering af ID’er uden serverforbindelse

Avancerede generatorfunktioner

Generering af UUID med brugerdefineret tid

For tidsbaserede versioner (v1, v6, v7) kan du vælge et vilkårligt tidsstempel ved hjælp af en dato-tid-vælger. Dette er nyttigt til:

Test:

• Simulering af UUID’er oprettet i fortiden
• Test af tidsbaseret sortering i databaser
• Reproduktion af UUID’er til debugging

Datamigration:

• Generering af UUID’er med historiske tidsstempler
• Tilbagefyldning af data med korrekte tidsstempelværdier
• Import af data fra forskellige tidsperioder

Revision og compliance:

• Rekonstruktion af UUID’er baseret på oprettelsestidspunkt for posten
• Retroaktiv generering af identifikatorer

Eksempel på brug:

1. Vælg version v1, v6 eller v7
2. Indstil dato og tid ved hjælp af dato-tid-vælgeren
3. Generer UUID med dit eget tidsstempel

Hash-baseret UUID (v3, v5)

For deterministiske UUID’er kan du bruge version v3 (MD5) eller v5 (SHA-1):

Sådan bruges:

1. Vælg namespace baseret på typen af din identifikator
2. Indtast navn/værdi
3. Generer UUID

Eksempler:

Vigtige egenskaber:

• ✅ Deterministisk: Samme input = altid samme UUID
• ✅ Reproducerbar: Du kan genskabe UUID’et når som helst
• ✅ Konsekvent: Samme UUID på tværs af forskellige systemer
• ❌ Kan ikke afkodes: Kan ikke gendanne det originale navn fra UUID’et
• ℹ️ Én UUID: For v3/v5 genereres altid kun én UUID (samme input = samme output)

Praktisk anvendelse:

// Eksempel: Konvertering af URL til UUID v5
Namespace: URL
Navn: https://example.com/api/users/123
Resultat: 886313e1-3b8a-5372-9b90-0c9aee199e5d

// Samme input = altid samme UUID
Namespace: DNS
Navn: google.com
Resultat: altid samme UUID for google.com

Hvordan bruges UUID’er sikkert?

Kryptografisk sikkerhed

Vores generator bruger crypto.getRandomValues(), som er en kryptografisk sikker tilfældighedsgenerator. I modsætning til Math.random(), som er forudsigelig og uegnet til sikkerhedsformål, giver crypto.getRandomValues() ægte entropi, der er egnet til:

• Generering af sikkerhedstokens
• Sessions-ID’er
• API-nøgler
• Kryptografiske applikationer

Sammenligning af UUID-versioner

UUID vs. andre identifikatorer

Implementering i forskellige sprog

JavaScript/TypeScript

// UUID v4 - Den nemmeste måde (moderne browsere)
const uuid = crypto.randomUUID();

// UUID v4 - Manuel implementering
function generateUUIDv4() {
  return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
    const r = (crypto.getRandomValues(new Uint8Array(1))[0] & 0x0f) >> (c === 'x' ? 0 : 2);
    const v = c === 'x' ? r : (r & 0x3) | 0x8;
    return v.toString(16);
  });
}

// UUID v7 - Anbefales til databaser
function generateUUIDv7() {
  const timestamp = Date.now();
  const timeHi = (timestamp >> 16).toString(16).padStart(8, '0');
  const timeLow = (timestamp & 0xFFFF).toString(16).padStart(4, '0');

  const randomBytes = crypto.getRandomValues(new Uint8Array(10));
  const randomHex = Array.from(randomBytes)
    .map(b => b.toString(16).padStart(2, '0'))
    .join('');

  return `${timeHi}-${timeLow}-7${randomHex.substr(0, 3)}-${randomHex.substr(3, 4)}-${randomHex.substr(7)}`;
}

Python

import uuid

# UUID v4
uuid_v4 = str(uuid.uuid4())
# Output: '6ba7b810-9dad-11d1-80b4-00c04fd430c8'

# UUID v1
uuid_v1 = str(uuid.uuid1())

Java

import java.util.UUID;

// UUID v4
String uuidV4 = UUID.randomUUID().toString();

PHP

// UUID v4 (PHP 7+)
function generateUUID() {
    return sprintf('%04x%04x-%04x-%04x-%04x-%04x%04x%04x',
        mt_rand(0, 0xffff), mt_rand(0, 0xffff),
        mt_rand(0, 0xffff),
        mt_rand(0, 0x0fff) | 0x4000,
        mt_rand(0, 0x3fff) | 0x8000,
        mt_rand(0, 0xffff), mt_rand(0, 0xffff), mt_rand(0, 0xffff)
    );
}

C#

using System;

// UUID v4
Guid uuid = Guid.NewGuid();
string uuidString = uuid.ToString();

Bedste Praksis

Lagring af UUID’er i databaser

PostgreSQL:

CREATE TABLE users (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    email VARCHAR(255) NOT NULL,
    created_at TIMESTAMP DEFAULT NOW()
);

MySQL 8.0+:

CREATE TABLE users (
    id BINARY(16) PRIMARY KEY DEFAULT (UUID_TO_BIN(UUID())),
    email VARCHAR(255) NOT NULL,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

Tip: I MySQL skal du gemme UUID’er som BINARY(16) i stedet for CHAR(36) for at spare plads og opnå hurtigere indeksering.

Validering af UUID’er

function isValidUUID(uuid) {
  const regex = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
  return regex.test(uuid);
}

Konvertering af UUID’er

// Fjern bindestreger
const compact = uuid.replace(/-/g, '');

// Tilføj bindestreger igen
function formatUUID(compactUuid) {
  return [
    compactUuid.substring(0, 8),
    compactUuid.substring(8, 12),
    compactUuid.substring(12, 16),
    compactUuid.substring(16, 20),
    compactUuid.substring(20, 32)
  ].join('-');
}

Fejlfinding (Troubleshooting)

UUID v3/v5 virker ikke

Problem: Efter valg af v3 eller v5 genereres intet

Løsning:

1. ✅ Kontroller, at du har udfyldt feltet “Navn” - det er obligatorisk!
2. ✅ Vælg det korrekte namespace baseret på typen af dit input
3. ✅ Eksempler på gyldige inputs:
   • DNS: example.com, google.com
   • URL: https://example.com/page
   • Enhver tekst: min-applikation-v1

Tip: Prøv først en simpel værdi som test og namespace DNS.

Tidsbaseret UUID (v1, v6, v7) har en mærkelig tid

Problem: Den genererede UUID har et uventet tidsstempel

Løsning:

1. ✅ Kontroller dato-tid-vælgeren - er den korrekte tid indstillet?
2. ✅ Dato-tid-vælgeren bruger din lokale tidszone
3. ✅ Lad dato-tid-vælgeren være tom for aktuel tid

UUID kan ikke kopieres

Problem: “Kopier alt”-knappen virker ikke

Løsning:

1. ✅ Kontroller, at du har genereret UUID’er (de er ikke tomme)
2. ✅ Nogle browsere kræver HTTPS for clipboard API’en
3. ✅ Alternativt, vælg teksten i textarea og kopier manuelt (Ctrl+C)

Ofte stillede spørgsmål (FAQ)

Alternativer til UUID

ULID (Universally Unique Lexicographically Sortable Identifier)

• 128-bit ID (ligesom UUID)
• Leksikografisk sorterbar efter oprettelsestidspunkt
• Mere kompakt repræsentation (26 tegn i stedet for 36)
• Case-insensitive base32-kodning

Eksempel: 01ARZ3NDEKTSV4RRFFQ69G5FAV

NanoID

• Mindre størrelse end UUID (21 tegn som standard)
• URL-venlig (uden specialtegn)
• Hurtigere generering
• Konfigurerbar længde og alfabet

Eksempel: V1StGXR8_Z5jdHi6B-myT

Snowflake ID (Twitter)

• 64-bit ID (mindre end UUID)
• Tidsbaseret sorterbar
• Indeholder worker ID og sekvensnummer
• Kræver centraliseret konfiguration

Eksempel: 1234567890123456789

Ydeevne og optimering

Genereringshastighed

Vores generator kan generere:

• 1 UUID: < 1 ms
• 100 UUID’er: ~10-20 ms
• 1000 UUID’er: ~100-200 ms

Tips til ydeevne

1. Batchgenerering – Hvis du har brug for mange UUID’er, generer dem på én gang i stedet for én ad gangen
2. DB-lagring – Indekser UUID-kolonner for hurtig søgning
3. Komprimering – Gem UUID’er i binær form (16 bytes) i stedet for som en streng (36 bytes)
4. Caching – I nogle tilfælde kan du forgenerere og cache UUID’er

Til udviklere

Struktur af UUID v4

xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx
|        |    |    |    |
|        |    |    |    └─ 48 bits tilfældige data (node)
|        |    |    └────── 16 bits tilfældige data med variant (clock_seq)
|        |    └─────────── 12 bits tilfældige data + 4 bits version (time_hi_and_version)
|        └──────────────── 16 bits tilfældige data (time_mid)
└───────────────────────── 32 bits tilfældige data (time_low)

• Version (4 bits): altid 0100 (binært) = 4 (hex)
• Variant (2-3 bits): altid 10 (binært) for RFC 4122

Test af UUID’er

// Jest-test
describe('UUID Generator', () => {
  test('generates valid UUID v4', () => {
    const uuid = generateUUIDv4();
    const regex = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
    expect(regex.test(uuid)).toBe(true);
  });

  test('generates unique UUIDs', () => {
    const uuid1 = generateUUIDv4();
    const uuid2 = generateUUIDv4();
    expect(uuid1).not.toBe(uuid2);
  });
});

Sikkerhedsaspekter

Hvad man ikke skal gøre med UUID’er

❌ Brug ikke UUID v1 til følsomme applikationer – Den indeholder et tidsstempel, hvilket kan udgøre en sikkerhedsrisiko

❌ Brug ikke Math.random() til generering af UUID’er – Det er ikke kryptografisk sikkert

❌ Stol ikke på UUID’er til autorisation – UUID’er kan gættes (selvom det er med en ekstremt lille sandsynlighed)

❌ Gem ikke UUID’er i cookies uden kryptering – Brug signed cookies eller JWT

Hvad man skal gøre

✅ Brug UUID v4 i de fleste tilfælde – Højeste entropi og sikkerhed

✅ Kombiner UUID’er med andre sikkerhedsforanstaltninger – Brug HTTPS, HttpOnly-cookies og kort udløbstid til session management

✅ Valider UUID’er på serveren – Kontroller altid formatet og versionen af UUID’er

✅ Brug kryptografisk sikre kilder til tilfældighed – crypto.getRandomValues() i browseren, /dev/urandom på Linux

Interesante fakta

• Antal mulige UUID v4: 2^122 ≈ 5.3 × 10^36 (340 undecillioner)
• Nødvendig kollision: For at have 50% chance for en kollision skal du generere 2.71 × 10^18 UUID’er (2.71 quintillioner)
• Størrelse af alle mulige UUID’er: Hvis vi gemte hver UUID som 16 bytes, ville hele pladsen fylde 85 zettabyte (85 milliarder terabytes)
• Oprindelse: UUID blev standardiseret som en del af DCE (Distributed Computing Environment) i 1990