Generator UUID online gratuit - Toate versiunile (v1-v7)

Ce este UUID?

UUID (Universally Unique Identifier) este un identificator pe 128 de biți utilizat în sistemele informatice pentru identificarea unică a informațiilor. UUID este standardizat conform RFC 4122 și, datorită entropiei sale enorme, garantează o probabilitate practic zero de coliziune – ceea ce înseamnă că două UUID-uri generate independent vor fi aproape sigur unice.

UUID-ul are un format standard: xxxxxxxx-xxxx-Mxxx-Nxxx-xxxxxxxxxxxx, unde fiecare x este o cifră hexazecimală (0-9, a-f), M indică versiunea UUID și N indică varianta.

Versiunile UUID

UUID v1 (Timestamp + adresă MAC)

UUID v1 se bazează pe timestamp-ul curent și o valoare aleatorie (în browser, în loc de adresă MAC). Utilizează intervale de 100 de nanosecunde începând cu 15 octombrie 1582 (calendarul gregorian).

Utilizare:

• Situații în care este necesară sortarea cronologică a UUID-urilor
• Debugging și logare (UUID conține informații despre timpul creării)
• Sisteme distribuite cu sincronizare temporală

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

Avantaje:

• UUID-urile pot fi sortate cronologic după timpul creării
• Utile pentru audit și debugging
• Conține informații despre timestamp

Dezavantaje:

• Risc potențial de securitate – conține timestamp-ul
• În browser nu conține adresa MAC reală (înlocuită cu o valoare aleatorie)
• Localitate slabă a bazei de date (timestamp-ul este în biți de ordine inferioară)

UUID v3 (Hash MD5)

UUID v3 este generat folosind hash-ul MD5 al unui UUID de namespace și al unui nume. Deterministic – același namespace + nume va crea întotdeauna același UUID.

Utilizare:

• Conversia URL-urilor, numelor DNS sau a altor identificatori în UUID
• Situații în care sunt necesare UUID-uri reproductibile
• Maparea între diferite sisteme de identificare

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

Avantaje:

• Deterministic (același input = același output)
• Ideal pentru conversia identificatorilor cunoscuți
• Fără coliziuni pentru input-uri diferite

Dezavantaje:

• MD5 este un algoritm învechit (preferați v5)
• Necesită namespace și nume
• Nu se poate recupera input-ul original

UUID v4 (Aleatoriu) - RECOMANDAT

Cea mai utilizată versiune de UUID. UUID v4 este generat pur aleatoriu folosind un generator de numere aleatorii criptografic sigur (crypto.getRandomValues()).

Utilizare:

• Chei primare de baze de date
• Identificatori de sesiune (session IDs)
• Nume unice de fișiere
• Token-uri API
• Scopuri generale, unde este necesar un ID garantat unic

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

Avantaje:

• Entropie și securitate maximă
• Fără dependență de timp sau parametri de sistem
• Cea mai simplă implementare

Probabilitatea de coliziune: La generarea a 1 miliard de UUID-uri pe secundă timp de 100 de ani, șansa de coliziune este de aproximativ 0,00000006%.

UUID v5 (Hash SHA-1)

UUID v5 este la fel ca v3, dar utilizează SHA-1 în loc de MD5. O alternativă mai modernă și mai sigură la v3.

Utilizare:

• Același ca v3, dar cu o securitate mai bună
• Preferat în locul v3 pentru proiecte noi
• Generarea UUID-urilor din URL-uri, nume DNS, OID, X.500 DN

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

Avantaje:

• Deterministic
• SHA-1 este mai robust decât MD5
• Potrivit pentru maparea între sisteme

Dezavantaje:

• SHA-1 este, de asemenea, considerat învechit (dar încă mai sigur decât MD5)
• Necesită namespace și nume

UUID v6 (Timestamp ordonat)

UUID v6 este o versiune îmbunătățită a v1, cu biții temporali rearangați pentru o mai bună indexare a bazei de date. Proiectat pentru a rezolva problemele de localitate în bazele de date.

Utilizare:

• Chei primare de baze de date cu sortare cronologică
• Sisteme care necesită sortare cronologică și performanță DB
• Alternativă mai modernă la v1

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

Avantaje:

• Localitate DB mai bună decât v1 (timestamp în biți de ordine superioară)
• Sortare cronologică
• Compatibil cu standardul UUID

Dezavantaje:

• Mai puțin utilizat decât v1/v4
• Conține încă informații temporale (risc de securitate)

UUID v7 (Timestamp Unix)

UUID v7 utilizează timestamp-ul Unix (milisecunde din 1970) + biți aleatorii. Cea mai nouă versiune de UUID cu cea mai bună localitate DB.

Utilizare:

• Chei primare de baze de date moderne
• Sisteme care necesită performanță + sortare cronologică
• Înlocuitor pentru v1/v6 în proiecte noi

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

Avantaje:

• Cea mai bună localitate DB dintre toate versiunile
• Timestamp-ul Unix este standard
• Combină avantajele aleatorietății și ale sortării cronologice

Dezavantaje:

• Specificație relativ nouă (RFC 4122bis)
• Mai puțin suportată în sistemele legacy

Ce versiune de UUID să utilizezi?

Ghid de decizie

Ai nevoie de securitate maximă și aleatorietate? → Utilizează UUID v4 (cea mai comună alegere)

Ai nevoie de sortare cronologică și performanță DB? → Utilizează UUID v7 (modern) sau UUID v6 (standard)

Ai nevoie de UUID-uri reproductibile din identificatori existenți? → Utilizează UUID v5 (SHA-1) sau UUID v3 (MD5, legacy)

Ai nevoie de timestamp și audit trail? → Utilizează UUID v1 (legacy, performanță DB mai slabă)

Baze de date

Pentru proiecte noi: UUID v7 sau v4

• v7 este ideal pentru sortare cronologică + performanță
• v4 pentru aleatorietate maximă fără informații temporale

Pentru sisteme legacy: UUID v1 sau v6

• v6 are o localitate DB mai bună decât v1
• v1 este larg suportat

Avantaje UUID ca cheie primară:

• Unicitate globală – Poți conecta date din diferite baze de date fără conflict
• Securitate – Spre deosebire de ID-urile secvențiale (1, 2, 3…), nu poți ghici următoarele valori
• Sisteme distribuite – UUID-urile pot fi generate independent pe mai multe servere fără coordonare
• Unirea bazelor de date – La unirea a două baze de date nu apar conflicte

Dezavantaje:

• Dimensiune mai mare (16 octeți vs. 4-8 octeți pentru un întreg)
• Indexare mai lentă în unele baze de date (utilizați v6/v7 pentru o performanță mai bună)
• Mai puțin lizibil pentru oameni

API și servicii web

• REST API – Identificatori unici pentru resurse
• GraphQL – Identificatori globali pentru noduri
• Webhook-uri – Urmărirea cererilor și răspunsurilor
• Token-uri – ID-uri de sesiune, token-uri de reîmprospătare

Fișiere și stocare

• Nume de fișiere – Prevenirea coliziunilor la încărcare
• S3/Cloud Storage – Căi unice către obiecte
• Chei de cache – Identificatori în sistemele de cache

Aplicații Frontend

• Componente React/Vue – Chei unice pentru liste
• ID-uri temporare – ID-uri înainte de salvarea în baza de date
• Stocare locală – Chei pentru datele stocate
• Aplicații offline-first – Generarea de ID-uri fără conexiune la server

Funcții avansate ale generatorului

Generarea UUID cu timp personalizat

Pentru versiunile bazate pe timp (v1, v6, v7), puteți selecta orice timestamp folosind selectorul de dată și oră. Acest lucru este util pentru:

Testare:

• Simularea UUID-urilor create în trecut
• Testarea sortării cronologice în baze de date
• Reproducerea UUID-urilor pentru debugging

Migrare de date:

• Generarea UUID-urilor cu timestamp-uri istorice
• Populating de date cu valori timestamp corecte
• Importarea datelor din diferite perioade de timp

Audit și conformitate:

• Reconstrucția UUID-urilor conform timpului de creare a înregistrării
• Generarea retroactivă a identificatorilor

Exemplu de utilizare:

1. Selectați versiunea v1, v6 sau v7
2. Setați data și ora folosind selectorul de dată și oră
3. Generați UUID-ul cu timestamp-ul dvs. personalizat

UUID-uri bazate pe Hash (v3, v5)

Pentru UUID-uri deterministice, puteți utiliza versiunile v3 (MD5) sau v5 (SHA-1):

Cum se utilizează:

1. Selectați namespace-ul în funcție de tipul identificatorului dvs.
2. Introduceți numele/valoarea
3. Generați UUID-ul

Exemple:

Proprietăți importante:

• ✅ Deterministice: Același input = întotdeauna același UUID
• ✅ Reproductibile: Puteți recrea UUID-ul oricând
• ✅ Consistente: Același UUID în sisteme diferite
• ❌ Nu pot fi decodificate: Nu se poate obține numele original din UUID
• ℹ️ Un singur UUID: Pentru v3/v5 se generează întotdeauna un singur UUID (același input = același output)

Utilizare practică:

// Exemplu: Conversia URL-ului în UUID v5
Namespace: URL
Nume: https://example.com/api/users/123
Rezultat: 886313e1-3b8a-5372-9b90-0c9aee199e5d

// Același input = întotdeauna același UUID
Namespace: DNS
Nume: google.com
Rezultat: întotdeauna același UUID pentru google.com

Cum să utilizezi UUID-urile în siguranță?

Securitate Criptografică

Generatorul nostru utilizează crypto.getRandomValues(), care este un generator de numere aleatorii criptografic sigur. Spre deosebire de Math.random(), care este previzibil și nepotrivit pentru scopuri de securitate, crypto.getRandomValues() oferă entropie reală potrivită pentru:

• Generarea de token-uri de securitate
• ID-uri de sesiune
• Chei API
• Aplicații criptografice

Comparația versiunilor UUID

UUID vs. alți identificatori

Implementare în diferite limbaje

JavaScript/TypeScript

// UUID v4 - Cel mai simplu mod (browsere moderne)
const uuid = crypto.randomUUID();

// UUID v4 - Implementare manuală
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 - Recomandat pentru baze de date
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();

Bune Practici

Stocarea UUID-urilor în baze de date

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

Sfat: În MySQL, stocați UUID-urile ca BINARY(16) în loc de CHAR(36) pentru economie de spațiu și indexare mai rapidă.

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

Conversia UUID

// Eliminarea liniuțelor
const compact = uuid.replace(/-/g, '');

// Adăugarea liniuțelor înapoi
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('-');
}

Rezolvarea problemelor (Troubleshooting)

UUID v3/v5 nu funcționează

Problemă: După selectarea v3 sau v5, nimic nu este generat

Soluție:

1. ✅ Verificați dacă ați completat câmpul “Nume” - este obligatoriu!
2. ✅ Selectați namespace-ul corect în funcție de tipul input-ului dvs.
3. ✅ Exemple de input-uri valide:
   • DNS: example.com, google.com
   • URL: https://example.com/page
   • Orice text: aplicatia-mea-v1

Sfat: Încercați mai întâi o valoare simplă, cum ar fi test și namespace DNS.

UUID-ul bazat pe timp (v1, v6, v7) are o oră ciudată

Problemă: UUID-ul generat are un timestamp neașteptat

Soluție:

1. ✅ Verificați selectorul de dată și oră - este setată ora corectă?
2. ✅ Selectorul de dată și oră utilizează fusul orar local
3. ✅ Lăsați selectorul de dată și oră gol pentru ora curentă

UUID-ul nu poate fi copiat

Problemă: Butonul “Copiază tot” nu funcționează

Soluție:

1. ✅ Verificați dacă ați generat UUID-uri (nu sunt goale)
2. ✅ Unele browsere necesită HTTPS pentru API-ul clipboard
3. ✅ Alternativ, selectați textul din caseta text și copiați manual (Ctrl+C)

Întrebări Frecvente (FAQ)

Alternative la UUID

ULID (Universally Unique Lexicographically Sortable Identifier)

• ID pe 128 de biți (la fel ca UUID)
• Sortabil lexicografic după timpul creării
• Reprezentare mai compactă (26 de caractere în loc de 36)
• Codificare base32 insensibilă la majuscule/minuscule

Exemplu: 01ARZ3NDEKTSV4RRFFQ69G5FAV

NanoID

• Dimensiune mai mică decât UUID (21 de caractere standard)
• URL-friendly (fără caractere speciale)
• Generare mai rapidă
• Lungime și alfabet configurabile

Exemplu: V1StGXR8_Z5jdHi6B-myT

Snowflake ID (Twitter)

• ID pe 64 de biți (mai mic decât UUID)
• Sortabil temporal
• Conține ID-ul workerului și numărul de secvență
• Necesită o configurare centralizată

Exemplu: 1234567890123456789

Performanță și optimizare

Viteza de generare

Generatorul nostru poate genera:

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

Sfaturi pentru performanță

1. Generare în lot – Dacă aveți nevoie de multe UUID-uri, generați-le pe toate odată, în loc de unul câte unul
2. Stocare în DB – Indexați coloanele UUID pentru căutări rapide
3. Compresie – Stocați UUID-urile în format binar (16 octeți) în loc de string (36 octeți)
4. Caching – În unele cazuri, puteți pre-genera și memora UUID-urile

Pentru dezvoltatori

Structura UUID v4

xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx
|        |    |    |    |
|        |    |    |    └─ 48 biți de date aleatorii (nod)
|        |    |    └────── 16 biți de date aleatorii cu variantă (clock_seq)
|        |    └─────────── 12 biți de date aleatorii + 4 biți de versiune (time_hi_and_version)
|        └──────────────── 16 biți de date aleatorii (time_mid)
└───────────────────────── 32 biți de date aleatorii (time_low)

• Versiune (4 biți): întotdeauna 0100 (binar) = 4 (hex)
• Variantă (2-3 biți): întotdeauna 10 (binar) pentru RFC 4122

Testarea UUID

// Test Jest
describe('UUID Generator', () => {
  test('generează UUID v4 valid', () => {
    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('generează UUID-uri unice', () => {
    const uuid1 = generateUUIDv4();
    const uuid2 = generateUUIDv4();
    expect(uuid1).not.toBe(uuid2);
  });
});

Aspecte de securitate

Ce să NU faci cu UUID-urile

❌ Nu utiliza UUID v1 pentru aplicații sensibile – Conține un timestamp, ceea ce poate fi un risc de securitate

❌ Nu utiliza Math.random() pentru generarea UUID-urilor – Nu este criptografic sigur

❌ Nu te baza pe UUID-uri pentru autorizare – UUID-urile pot fi ghicite (chiar dacă cu o probabilitate extrem de mică)

❌ Nu stoca UUID-uri în cookie-uri fără criptare – Utilizează cookie-uri semnate sau JWT

Ce să faci

✅ Utilizează UUID v4 pentru majoritatea cazurilor – Cea mai înaltă entropie și securitate

✅ Combină UUID-urile cu alte măsuri de securitate – Pentru gestionarea sesiunilor, utilizează HTTPS, cookie-uri HttpOnly și o expirare scurtă

✅ Validează UUID-urile pe server – Verifică întotdeauna formatul și versiunea UUID-ului

✅ Utilizează surse de aleatorietate criptografic sigure – crypto.getRandomValues() în browser, /dev/urandom pe Linux

Curiozități

• Numărul de UUID-uri v4 posibile: 2^122 ≈ 5.3 × 10^36 (340 undecilioni)
• Coliziunea necesară: Pentru o șansă de 50% de coliziune, trebuie să generezi 2.71 × 10^18 UUID-uri (2.71 cvintilioni)
• Dimensiunea tuturor UUID-urilor posibile: Dacă am stoca fiecare UUID ca 16 octeți, întregul spațiu ar ocupa 85 de zettabytes (85 de miliarde de terabytes)
• Origine: UUID a fost standardizat ca parte a DCE (Distributed Computing Environment) în 1990