UUID-generator | Generera unika ID:n online gratis

Vad är UUID?

UUID (Universally Unique Identifier) är en 128-bitars identifierare som används i datorsystem för att unikt identifiera information. UUID är standardiserat enligt RFC 4122 och garanterar, tack vare sin enorma entropi, en praktiskt taget noll sannolikhet för kollision – vilket innebär att två oberoende genererade UUID nästan säkert kommer att vara unika.

UUID har ett standardformat: xxxxxxxx-xxxx-Mxxx-Nxxx-xxxxxxxxxxxx, där varje x är en hexadecimal siffra (0-9, a-f), M anger UUID-versionen och N anger varianten.

UUID-versioner

UUID v1 (Tidsstämpel + MAC-adress)

UUID v1 är baserat på en aktuell tidsstämpel och ett slumpmässigt värde (i webbläsaren istället för en MAC-adress). Det använder 100-nanosekundsintervaller sedan den 15 oktober 1582 (Gregorianska kalendern).

Användningsområden:

• Situationer där du behöver kronologisk sortering av UUID
• Felsökning och loggning (UUID innehåller information om skapandetid)
• Distribuerade system med tidssynkronisering

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

Fördelar:

• UUID kan sorteras kronologiskt efter skapandetid
• Användbart för revision och felsökning
• Innehåller tidsstämpelinformation

Nackdelar:

• Potentiell säkerhetsrisk – innehåller en tidsstämpel
• Innehåller inte en verklig MAC-adress i webbläsaren (ersatt med ett slumpmässigt värde)
• Dålig DB-lokalitet (tidsstämpeln är i de lägre bitarna)

UUID v3 (MD5 hash)

UUID v3 genereras med hjälp av en MD5-hash av en namnrymd-UUID och ett namn. Deterministiskt – samma namnrymd + namn kommer alltid att skapa samma UUID.

Användningsområden:

• Konvertering av URL:er, DNS-namn eller andra identifierare till UUID
• Situationer där du behöver reproducerbara UUID
• Mappning mellan olika identifieringssystem

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

Fördelar:

• Deterministiskt (samma input = samma output)
• Idealisk för konvertering av kända identifierare
• Ingen kollision för olika inputs

Nackdelar:

• MD5 är en föråldrad algoritm (föredra v5)
• Kräver namnrymd och namn
• Det går inte att återställa den ursprungliga inputen

UUID v4 (Slumpmässigt) - REKOMMENDERAS

Den mest använda UUID-versionen. UUID v4 genereras helt slumpmässigt med hjälp av en kryptografiskt säker slumptalsgenerator (crypto.getRandomValues()).

Användningsområden:

• Primärnycklar i databaser
• Sessionsidentifierare (session-ID:n)
• Unika filnamn
• API-token
• Allmänna ändamål där du behöver garanterat unika ID:n

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

Fördelar:

• Maximal entropi och säkerhet
• Inget beroende av tid eller systemparametrar
• Enklaste implementeringen

Sannolikhet för kollision: Vid generering av 1 miljard UUID per sekund i 100 år är chansen för kollision cirka 0,00000006%.

UUID v5 (SHA-1 hash)

UUID v5 är detsamma som v3, men använder SHA-1 istället för MD5. Ett modernare och säkrare alternativ till v3.

Användningsområden:

• Samma som v3, men med bättre säkerhet
• Föredras framför v3 för nya projekt
• Generering av UUID från URL:er, DNS-namn, OID, X.500 DN

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

Fördelar:

• Deterministiskt
• SHA-1 är mer robust än MD5
• Lämplig för mappning mellan system

Nackdelar:

• SHA-1 anses också vara föråldrat (men fortfarande säkrare än MD5)
• Kräver namnrymd och namn

UUID v6 (Sorterad tidsstämpel)

UUID v6 är en förbättrad version av v1 med omordnade tidsbitar för bättre DB-indexering. Designad för att lösa lokalitetsproblem i databaser.

Användningsområden:

• Primärnycklar i databaser med tidsbaserad sortering
• System som kräver kronologisk sortering och DB-prestanda
• Modernare alternativ till v1

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

Fördelar:

• Bättre DB-lokalitet än v1 (tidsstämpel i högre ordningsbitar)
• Kronologisk sortering
• Kompatibel med UUID-standarden

Nackdelar:

• Mindre använt än v1/v4
• Innehåller fortfarande tidsinformation (säkerhetsrisk)

UUID v7 (Unix tidsstämpel)

UUID v7 använder Unix tidsstämpel (millisekunder sedan 1970) + slumpmässiga bitar. Den senaste UUID-versionen med bästa DB-lokalitet.

Användningsområden:

• Moderna primärnycklar i databaser
• System som kräver prestanda + tidsbaserad sortering
• Ersättning för v1/v6 i nya projekt

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

Fördelar:

• Bästa DB-lokalitet av alla versioner
• Unix tidsstämpel är standard
• Kombinerar fördelarna med slumpmässighet och tidsbaserad sortering

Nackdelar:

• Relativt ny specifikation (RFC 4122bis)
• Mindre stöd i äldre system

Vilken UUID-version ska man använda?

Beslutsguide

Behöver du maximal säkerhet och slumpmässighet? → Använd UUID v4 (vanligaste valet)

Behöver du tidsbaserad sortering och DB-prestanda? → Använd UUID v7 (modernt) eller UUID v6 (standard)

Behöver du reproducerbara UUID från befintliga identifierare? → Använd UUID v5 (SHA-1) eller UUID v3 (MD5, äldre)

Behöver du tidsstämpel och revisionsspår? → Använd UUID v1 (äldre, sämre DB-prestanda)

Databaser

För nya projekt: UUID v7 eller v4

• v7 är idealisk för tidsbaserad sortering + prestanda
• v4 för maximal slumpmässighet utan tidsinformation

För äldre system: UUID v1 eller v6

• v6 har bättre DB-lokalitet än v1
• v1 stöds brett

Fördelar med UUID som primärnyckel:

• Global unikhet – Du kan koppla ihop data från olika databaser utan konflikt
• Säkerhet – Till skillnad från sekventiella ID:n (1, 2, 3…) kan nästa värden inte gissas
• Distribuerade system – UUID kan genereras oberoende på flera servrar utan samordning
• Databasmärgen – Vid sammanslagning av två databaser uppstår inga konflikter

Nackdelar:

• Större storlek (16 byte vs 4-8 byte för heltal)
• Långsammare indexering i vissa databaser (använd v6/v7 för bättre prestanda)
• Mindre läsbart för människor

API:er och webbtjänster

• REST API – Unika identifierare för resurser
• GraphQL – Globala identifierare för noder
• Webhooks – Spårning av förfrågningar och svar
• Token – Sessions-ID:n, refresh-token

Filer och lagring

• Filnamn – Förhindrar kollisioner vid uppladdning
• S3/Molnlagring – Unika sökvägar till objekt
• Cache-nycklar – Identifierare i cache-system

Frontend-applikationer

• React/Vue-komponenter – Unika nycklar för listor
• Temporära ID:n – ID före lagring i databasen
• Lokal lagring – Nycklar för sparade data
• Offline-first applikationer – Genererar ID utan serveranslutning

Avancerade generatorfunktioner

Generera UUID med anpassad tid

För tidsbaserade versioner (v1, v6, v7) kan du välja vilken tidsstämpel som helst med hjälp av datum- och tidsväljaren. Detta är användbart för:

Testning:

• Simulering av UUID skapade i det förflutna
• Testning av tidsbaserad sortering i databaser
• Reproducering av UUID för felsökning

Datamigrering:

• Generering av UUID med historiska tidsstämplar
• Efterfyllning av data med korrekta tidsstämpelvärden
• Import av data från olika tidsperioder

Revision och efterlevnad:

• Rekonstruktion av UUID baserat på tidpunkten för postens skapande
• Retroaktiv generering av identifierare

Exempel på användning:

1. Välj version v1, v6 eller v7
2. Ställ in datum och tid med hjälp av datum- och tidsväljaren
3. Generera UUID med din egen tidsstämpel

Hash-baserade UUID (v3, v5)

För deterministiska UUID kan du använda versionerna v3 (MD5) eller v5 (SHA-1):

Hur man använder:

1. Välj namnrymd efter typen av din identifierare
2. Ange namn/värde
3. Generera UUID

Exempel:

Viktiga egenskaper:

• ✅ Deterministiskt: Samma input = alltid samma UUID
• ✅ Reproducerbart: Du kan återskapa UUID när som helst
• ✅ Konsekvent: Samma UUID över olika system
• ❌ Kan inte avkodas: Den ursprungliga namnet kan inte hämtas från UUID
• ℹ️ Ett UUID: För v3/v5 genereras alltid bara ett UUID (samma input = samma output)

Praktisk användning:

// Exempel: Konvertera URL till UUID v5
Namnrymd: URL
Namn: https://example.com/api/users/123
Resultat: 886313e1-3b8a-5372-9b90-0c9aee199e5d

// Samma input = alltid samma UUID
Namnrymd: DNS
Namn: google.com
Resultat: alltid samma UUID för google.com

Hur man använder UUID säkert?

Kryptografisk säkerhet

Vår generator använder crypto.getRandomValues(), vilket är en kryptografiskt säker slumptalsgenerator. Till skillnad från Math.random(), som är förutsägbar och olämplig för säkerhetsändamål, ger crypto.getRandomValues() verklig entropi lämplig för:

• Generering av säkerhetstoken
• Sessions-ID:n
• API-nycklar
• Kryptografiska applikationer

Jämförelse av UUID-versioner

UUID vs andra identifierare

Implementering i olika språk

JavaScript/TypeScript

// UUID v4 - Enklaste sättet (moderna webbläsare)
const uuid = crypto.randomUUID();

// UUID v4 - Manuell 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 - Rekommenderas för 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();

Bästa praxis

Lagring av UUID i databasen

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 lagra UUID som BINARY(16) istället för CHAR(36) för att spara utrymme och snabbare indexering.

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

// Ta bort bindestreck
const compact = uuid.replace(/-/g, '');

// Lägg till bindestreck 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('-');
}

Felsökning (Troubleshooting)

UUID v3/v5 fungerar inte

Problem: Efter att ha valt v3 eller v5 genereras inget

Lösning:

1. ✅ Kontrollera att du har fyllt i fältet “Namn” - det är obligatoriskt!
2. ✅ Välj rätt namnrymd enligt typen av din input
3. ✅ Exempel på giltiga inputs:
   • DNS: example.com, google.com
   • URL: https://example.com/page
   • Valfri text: min-applikation-v1

Tips: Försök först med ett enkelt värde som test och namnrymden DNS.

Tidsbaserat UUID (v1, v6, v7) har en konstig tid

Problem: Det genererade UUID:t har en oväntad tidsstämpel

Lösning:

1. ✅ Kontrollera datum- och tidsväljaren - är rätt tid inställd?
2. ✅ Datum- och tidsväljaren använder din lokala tidszon
3. ✅ Lämna datum- och tidsväljaren tom för aktuell tid

UUID kan inte kopieras

Problem: Knappen “Kopiera alla” fungerar inte

Lösning:

1. ✅ Kontrollera att du har genererat UUID:n (att de inte är tomma)
2. ✅ Vissa webbläsare kräver HTTPS för clipboard API
3. ✅ Alternativt, markera texten i textrutan och kopiera manuellt (Ctrl+C)

Vanliga frågor (FAQ)

xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx
|        |    |    |    |
|        |    |    |    └─ 48 bitar slumpmässig data (nod)
|        |    |    └────── 16 bitar slumpmässig data med variant (clock_seq)
|        |    └─────────── 12 bitar slumpmässig data + 4 bitar version (time_hi_and_version)
|        └──────────────── 16 bitar slumpmässig data (time_mid)
└───────────────────────── 32 bitar slumpmässig data (time_low)

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