UUID-generator | Generer unike ID-er online (v1-v7)

Hva er UUID?

UUID (Universally Unique Identifier) er en 128-bits identifikator som brukes i datasystemer for å unikt identifisere informasjon. UUID er standardisert under RFC 4122, og takket være sin enorme entropi garanterer den praktisk talt null sannsynlighet for kollisjon – noe som betyr at to uavhengig genererte UUID-er nesten helt sikkert vil være unike.

En UUID har et standardformat: xxxxxxxx-xxxx-Mxxx-Nxxx-xxxxxxxxxxxx, hvor hver x er et heksadesimalt siffer (0-9, a-f), M angir UUID-versjonen, og N angir varianten.

UUID-versjoner

UUID v1 (Tidsstempel + MAC-adresse)

UUID v1 er basert på gjeldende tidsstempel og en tilfeldig verdi (i nettleseren i stedet for MAC-adresse). Den bruker 100-nanosekunders intervaller fra 15. oktober 1582 (Gregoriansk kalender).

Bruk:

• Situasjoner der du trenger kronologisk sortering av UUID-er
• Feilsøking og logging (UUID inneholder informasjon om opprettelsestidspunktet)
• Distribuerte systemer med tidssynkronisering

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

Fordeler:

• UUID-er kan sorteres kronologisk etter opprettelsestidspunkt
• Nyttig for revisjon og feilsøking
• Inneholder tidsstempelinformasjon

Ulemper:

• Potensiell sikkerhetsrisiko – inneholder tidsstempel
• I nettleseren inneholder den ikke en faktisk MAC-adresse (erstattet med en tilfeldig verdi)
• Dårlig DB-lokalitet (tidsstempel er i laveste ordens biter)

UUID v3 (MD5-hash)

UUID v3 genereres ved hjelp av en MD5-hash av et navneområde-UUID og et navn. Deterministisk – samme navneområde + navn vil alltid generere samme UUID.

Bruk:

• Konvertering av URL-er, DNS-navn eller andre identifikatorer til UUID-er
• Situasjoner der du trenger reproduserbare UUID-er
• Kartlegging mellom forskjellige identifikasjonssystemer

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

Fordeler:

• Deterministisk (samme input = samme output)
• Ideell for konvertering av kjente identifikatorer
• Ingen kollisjon for forskjellige inputs

Ulemper:

• MD5 er en foreldet algoritme (foretrekk v5)
• Krever navneområde og navn
• Kan ikke gjenopprette original input

UUID v4 (Tilfeldig) - ANBEFALT

Den mest brukte UUID-versjonen. UUID v4 genereres rent tilfeldig ved hjelp av en kryptografisk sikker tilfeldig tallgenerator (crypto.getRandomValues()).

Bruk:

• Primærnøkler i databaser
• Sesjonsidentifikatorer (session IDs)
• Unike filnavn
• API-token
• Generelle formål der du trenger en garantert unik ID

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

Fordeler:

• Maksimal entropi og sikkerhet
• Ingen avhengighet av tid eller systemparametere
• Enkleste implementasjon

Sannsynlighet for kollisjon: Ved generering av 1 milliard UUID-er per sekund i 100 år er sjansen for kollisjon omtrent 0,00000006%.

UUID v5 (SHA-1-hash)

UUID v5 er det samme som v3, men bruker SHA-1 i stedet for MD5. Et mer moderne og sikrere alternativ til v3.

Bruk:

• Samme som v3, men med bedre sikkerhet
• Foretrukket fremfor v3 for nye prosjekter
• Generering av UUID-er fra URL-er, DNS-navn, OID, X.500 DN

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

Fordeler:

• Deterministisk
• SHA-1 er mer robust enn MD5
• Egnet for kartlegging mellom systemer

Ulemper:

• SHA-1 regnes også som foreldet (men fortsatt sikrere enn MD5)
• Krever navneområde og navn

UUID v6 (Sortert tidsstempel)

UUID v6 er en forbedret versjon av v1 med omorganiserte tidsbiter for bedre DB-indeksering. Designet for å løse problemer med lokalitet i databaser.

Bruk:

• Primærnøkler i databaser med tidsbasert sortering
• Systemer som krever både kronologisk sortering og DB-ytelse
• Et mer moderne alternativ til v1

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

Fordeler:

• Bedre DB-lokalitet enn v1 (tidsstempel i høyeste ordens biter)
• Kronologisk sortering
• Kompatibel med UUID-standarden

Ulemper:

• Mindre brukt enn v1/v4
• Inneholder fortsatt tidsinformasjon (sikkerhetsrisiko)

UUID v7 (Unix-tidsstempel)

UUID v7 bruker Unix-tidsstempel (millisekunder fra 1970) + tilfeldige biter. Den nyeste UUID-versjonen med best DB-lokalitet.

Bruk:

• Moderne primærnøkler i databaser
• Systemer som krever ytelse + tidsbasert sortering
• Erstatning for v1/v6 i nye prosjekter

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

Fordeler:

• Best DB-lokalitet av alle versjoner
• Unix-tidsstempel er standard
• Kombinerer fordelene med tilfeldighet og tidsbasert sortering

Ulemper:

• Relativt ny spesifikasjon (RFC 4122bis)
• Mindre støttet i eldre systemer

Hvilken UUID-versjon skal jeg bruke?

Beslutningsguide

Trenger du maksimal sikkerhet og tilfeldighet? → Bruk UUID v4 (det vanligste valget)

Trenger du tidsbasert sortering og DB-ytelse? → Bruk UUID v7 (moderne) eller UUID v6 (standard)

Trenger du reproduserbare UUID-er fra eksisterende identifikatorer? → Bruk UUID v5 (SHA-1) eller UUID v3 (MD5, eldre)

Trenger du tidsstempel og revisjonsspor? → Bruk UUID v1 (eldre, dårligere DB-ytelse)

Databaser

For nye prosjekter: UUID v7 eller v4

• v7 er ideell for tidsbasert sortering + ytelse
• v4 for maksimal tilfeldighet uten tidsinformasjon

For eldre systemer: UUID v1 eller v6

• v6 har bedre DB-lokalitet enn v1
• v1 er bredt støttet

Fordeler med UUID som primærnøkkel:

• Global unikhet – Du kan koble data fra forskjellige databaser uten konflikt
• Sikkerhet – I motsetning til sekvensielle ID-er (1, 2, 3…) kan ikke neste verdier gjettes
• Distribuerte systemer – UUID-er kan genereres uavhengig på flere servere uten koordinering
• Slå sammen databaser – Ved sammenslåing av to databaser oppstår det ingen konflikter

Ulemper:

• Større størrelse (16 byte vs 4-8 byte for integer)
• Saktere indeksering i noen databaser (bruk v6/v7 for bedre ytelse)
• Mindre lesbar for mennesker

API-er og webtjenester

• REST API – Unike identifikatorer for ressurser
• GraphQL – Globale identifikatorer for noder
• Webhooker – Sporing av forespørsler og svar
• Tokener – Sesjons-ID-er, refresh-token

Filer og lagring

• Filnavn – Forebygging av kollisjoner ved opplasting
• S3/Cloud Storage – Unike baner til objekter
• Cache-nøkler – Identifikatorer i cachesystemer

Frontend-applikasjoner

• React/Vue-komponenter – Unike nøkler for lister
• Midlertidige ID-er – ID-er før lagring i database
• Lokal lagring – Nøkler for lagrede data
• Offline-først applikasjoner – Generering av ID-er uten servertilkobling

Avanserte funksjoner i generatoren

Generere UUID med tilpasset tid

For tidsbaserte versjoner (v1, v6, v7) kan du velge et hvilket som helst tidsstempel ved hjelp av datovelgeren. Dette er nyttig for:

Testing:

• Simulering av UUID-er opprettet i fortiden
• Testing av tidsbasert sortering i databaser
• Reproduksjon av UUID-er for feilsøking

Datamigrering:

• Generering av UUID-er med historiske tidsstempler
• Etterfylling av data med korrekte tidsstempelverdier
• Import av data fra forskjellige tidsperioder

Revisjon og compliance:

• Rekonstruksjon av UUID-er basert på opprettelsestidspunktet for en post
• Retroaktiv generering av identifikatorer

Eksempel på bruk:

1. Velg versjon v1, v6 eller v7
2. Angi dato og klokkeslett ved hjelp av datovelgeren
3. Generer UUID-er med ditt eget tidsstempel

Hash-basert UUID (v3, v5)

For deterministiske UUID-er kan du bruke versjon v3 (MD5) eller v5 (SHA-1):

Slik bruker du det:

1. Velg navneområde i henhold til typen av din identifikator
2. Skriv inn navnet/verdien
3. Generer UUID

Eksempler:

Viktige egenskaper:

• ✅ Deterministisk: Samme input = alltid samme UUID
• ✅ Reproducerbar: Du kan gjenskape UUID-en når som helst
• ✅ Konsistent: Samme UUID på tvers av forskjellige systemer
• ❌ Kan ikke dekodes: Originalt navn kan ikke gjenopprettes fra UUID
• ℹ️ Én UUID: For v3/v5 genereres alltid bare én UUID (samme input = samme output)

Praktisk bruk:

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

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

Hvordan bruke UUID trygt?

Kryptografisk sikkerhet

Vår generator bruker crypto.getRandomValues(), som er en kryptografisk sikker tilfeldig tallgenerator. I motsetning til Math.random(), som er forutsigbar og uegnet for sikkerhetsformål, gir crypto.getRandomValues() ekte entropi som er egnet for:

• Generering av sikkerhetstoken
• Sesjons-ID-er
• API-nøkler
• Kryptografiske applikasjoner

Sammenligning av UUID-versjoner

UUID vs. andre identifikatorer

Implementering i forskjellige språk

JavaScript/TypeScript

// UUID v4 - Den enkleste måten (moderne nettlesere)
const uuid = crypto.randomUUID();

// UUID v4 - Manuell implementasjon
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 - Anbefalt for 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();

Beste praksis

Lagre UUID-er i database

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

Tips: I MySQL lagrer du UUID-er som BINARY(16) i stedet for CHAR(36) for å spare plass og for raskere indeksering.

Validering av UUID

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 av UUID

// Fjerning av bindestreker
const compact = uuid.replace(/-/g, '');

// Legge til bindestreker igjen
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('-');
}

Feilsøking

UUID v3/v5 fungerer ikke

Problem: Ingenting genereres etter å ha valgt v3 eller v5

Løsning:

1. ✅ Kontroller at du har fylt ut “Navn”-feltet - det er obligatorisk!
2. ✅ Velg riktig navneområde i henhold til inndatatypen
3. ✅ Eksempler på gyldige inndata:
   • DNS: example.com, google.com
   • URL: https://example.com/page
   • Enhver tekst: min-applikasjon-v1

Tips: Prøv først en enkel verdi som test og navneområde DNS.

Tidsbasert UUID (v1, v6, v7) har en merkelig tid

Problem: Den genererte UUID-en har et uventet tidsstempel

Løsning:

1. ✅ Kontroller datovelgeren - er riktig tid angitt?
2. ✅ Datovelgeren bruker din lokale tidssone
3. ✅ La datovelgeren stå tom for å bruke nåværende tid

UUID kan ikke kopieres

Problem: “Kopier alt”-knappen fungerer ikke

Løsning:

1. ✅ Kontroller at du har generert UUID-er (at de ikke er tomme)
2. ✅ Noen nettlesere krever HTTPS for utklippstavle-API
3. ✅ Alternativt, velg teksten i tekstområdet og kopier manuelt (Ctrl+C)

Ofte stilte spørsmål (FAQ)

Alternativer til UUID

ULID (Universally Unique Lexicographically Sortable Identifier)

• 128-bits ID (samme som UUID)
• Leksikografisk sorterbar etter opprettelsestidspunkt
• Mer kompakt representasjon (26 tegn i stedet for 36)
• Case-insensitiv base32-koding

Eksempel: 01ARZ3NDEKTSV4RRFFQ69G5FAV

NanoID

• Mindre størrelse enn UUID (standard 21 tegn)
• URL-vennlig (uten spesialtegn)
• Raskere generering
• Konfigurerbar lengde og alfabet

Eksempel: V1StGXR8_Z5jdHi6B-myT

Snowflake ID (Twitter)

• 64-bits ID (mindre enn UUID)
• Tidsbasert sorterbar
• Inneholder worker ID og sekvensnummer
• Krever sentralisert konfigurasjon

Eksempel: 1234567890123456789

Ytelse og optimalisering

Genereringshastighet

Vår generator kan generere:

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

Tips for ytelse

1. Batch-generering – Hvis du trenger mange UUID-er, generer dem samtidig i stedet for én om gangen
2. Lagring i DB – Indekser UUID-kolonner for raskt søk
3. Komprimering – Lagre UUID-er i binær form (16 byte) i stedet for streng (36 byte)
4. Caching – I noen tilfeller kan du forhåndsgenerere og cache UUID-er

For utviklere

Struktur av UUID v4

xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx
|        |    |    |    |
|        |    |    |    └─ 48 biter med tilfeldige data (node)
|        |    |    └────── 16 biter med tilfeldige data med variant (clock_seq)
|        |    └─────────── 12 biter med tilfeldige data + 4 biter versjon (time_hi_and_version)
|        └──────────────── 16 biter med tilfeldige data (time_mid)
└───────────────────────── 32 biter med tilfeldige data (time_low)

• Versjon (4 biter): alltid 0100 (binært) = 4 (heksadesimalt)
• Variant (2-3 biter): alltid 10 (binært) for RFC 4122

Testing av UUID

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

Sikkerhetsaspekter

Hva du ikke skal gjøre med UUID

❌ Ikke bruk UUID v1 for sensitive applikasjoner – Inneholder tidsstempel, noe som kan være en sikkerhetsrisiko

❌ Ikke bruk Math.random() for å generere UUID-er – Er ikke kryptografisk sikker

❌ Ikke stol på UUID for autorisasjon – UUID-er kan gjettes (selv om sannsynligheten er ekstremt liten)

❌ Ikke lagre UUID-er i informasjonskapsler uten kryptering – Bruk signerte informasjonskapsler eller JWT

Hva du skal gjøre

✅ Bruk UUID v4 for de fleste tilfeller – Høyest entropi og sikkerhet

✅ Kombiner UUID med andre sikkerhetstiltak – For sesjonshåndtering, bruk HTTPS, HttpOnly-informasjonskapsler og kort utløpstid

✅ Valider UUID-er på serveren – Kontroller alltid formatet og versjonen av UUID

✅ Bruk kryptografisk sikre kilder for tilfeldighet – crypto.getRandomValues() i nettleseren, /dev/urandom på Linux

Kuriosa

• Antall mulige UUID v4: 2^122 ≈ 5.3 × 10^36 (340 undecillioner)
• Nødvendig kollisjon: For 50% sjanse for kollisjon må du generere 2.71 × 10^18 UUID-er (2.71 quintillioner)
• Størrelsen på alle mulige UUID-er: Hvis vi lagret hver UUID som 16 byte, ville hele plassen tatt opp 85 zettabyte (85 milliarder terabyte)
• Opprinnelse: UUID ble standardisert som en del av DCE (Distributed Computing Environment) i 1990