# Generator UUID

> Generează UUID (Identificatori Unici Universali) gratuit. Suportă toate versiunile (v1, v3-v7) și generează mii de UUID-uri rapid. Simplu și eficient.

URL: https://acrafto.com/ro/generator-uuid/

Tools are interactive browser apps; there is no public API, no endpoints to call and no server-side processing. To use a tool, open its HTML page in a browser.

## 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:**

| Namespace | Nume (intrare) | Utilizare |
| --- | --- | --- |
| DNS | `example.com` | Conversia numelui de domeniu în UUID |
| DNS | `google.com` | Fiecare site web are un UUID unic |
| URL | `https://example.com/page` | Conversia URL-ului în UUID |
| URL | `https://api.example.com/users/123` | Endpoint API ca UUID |
| OID | `1.3.6.1.4.1.343` | Object Identifier în UUID |
| X.500 | `CN=John Doe,O=Company` | Distinguished Name în UUID |

**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

| Versiune | Bază | Coliziuni | Sortare Cronologică | Performanță DB | Utilizare |
| --- | --- | --- | --- | --- | --- |
| v1 | Timestamp + MAC | Scăzută | ✅ Da | ❌ Mai slabă | Legacy, audit |
| v3 | Hash MD5 | Niciuna (deterministic) | ❌ Nu | ⚠️ Medie | Conversii (legacy) |
| v4 | Aleatoriu | Extrem de scăzută | ❌ Nu | ⚠️ Medie | Utilizare generală |
| v5 | Hash SHA-1 | Niciuna (deterministic) | ❌ Nu | ⚠️ Medie | Conversii (recomandat) |
| v6 | Timestamp ordonat | Scăzută | ✅ Da | ✅ Mai bună | DB modernă cu timp |
| v7 | Timestamp Unix | Scăzută | ✅ Da | ✅ Cea mai bună | Proiecte noi |

### UUID vs. alți identificatori

| Tip | Dimensiune | Coliziuni | Sortare Cronologică | Utilizare |
| --- | --- | --- | --- | --- |
| ID auto-increment | 4-8 octeți | Garantat unic în tabel | ❌ | Aplicații simple, DB locală |
| UUID v4 | 16 octeți | Practic imposibilă | ❌ | Sisteme distribuite, API |
| UUID v7 | 16 octeți | Practic imposibilă | ✅ | DB modernă cu performanță |
| ULID | 16 octeți | Practic imposibilă | ✅ | UUID + sortare lexicografică |
| Snowflake ID | 8 octeți | Garantat unic cu o configurare corectă | ✅ | Twitter, sisteme distribuite |
| NanoID | Configurabil | Depinde de lungime | ❌ | ID-uri URL-friendly |

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

### Poate apărea o coliziune UUID?

Teoretic da, dar probabilitatea este astronomic de mică. La generarea a 1 miliard de UUID v4 pe secundă timp de 100 de ani, șansa de coliziune este de aproximativ 0,00000006%. În practică, o coliziune nu se întâmplă niciodată.

### Este UUID potrivit ca cheie primară în baza de date?

Depinde de caz. UUID este ideal pentru sistemele distribuite și situațiile în care este necesară unicitatea globală. Pentru aplicațiile simple cu o singură bază de date, auto-incrementul poate fi mai eficient.

### UUID-urile generate cu acest instrument sunt sigure?

Da, utilizăm Web Crypto API (\`crypto.getRandomValues()\`), care oferă valori aleatorii criptografic sigure. Totul se întâmplă local în browserul dvs.

### Care este diferența între versiunile UUID?

\- \*\*v1\*\*: Timestamp + MAC/aleatoriu - sortare cronologică, performanță DB mai slabă - \*\*v3/v5\*\*: Bazat pe hash - deterministic, pentru conversia identificatorilor cunoscuți - \*\*v4\*\*: Aleatoriu - cel mai sigur, cel mai utilizat - \*\*v6\*\*: Timestamp rearanjat - performanță DB mai bună decât v1 - \*\*v7\*\*: Timestamp Unix - cea mai bună performanță DB + sortare cronologică

### Ce versiune de UUID ar trebui să utilizez?

Pentru majoritatea cazurilor, utilizați \*\*v4\*\* (aleatoriu). Pentru baze de date cu sortare cronologică, utilizați \*\*v7\*\* (modern) sau \*\*v6\*\* (standard). Pentru conversia identificatorilor cunoscuți (URL, DNS), utilizați \*\*v5\*\* (SHA-1).

### Pot utiliza UUID pentru token-uri și chei API?

UUID v4 este potrivit pentru ID-uri de sesiune și token-uri similare. Pentru chei API, luați în considerare utilizarea de stringuri aleatorii mai lungi (ex. valori pe 256 de biți) sau a bibliotecilor specializate.

### Cât de mari sunt UUID-urile?

Un UUID are 128 de biți (16 octeți). Într-un format string cu liniuțe, ocupă 36 de caractere. Fără liniuțe, 32 de caractere hexazecimale.

## 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

## Other languages

- Čeština (cs): [Generátor UUID](https://acrafto.com/cs/generator-uuid/) ([Markdown](https://acrafto.com/cs/generator-uuid/index.md))
- Slovenčina (sk): [UUID generátor](https://acrafto.com/sk/generator-uuid/) ([Markdown](https://acrafto.com/sk/generator-uuid/index.md))
- English (en): [UUID Generator](https://acrafto.com/en/uuid-generator/) ([Markdown](https://acrafto.com/en/uuid-generator/index.md))
- Deutsch (de): [UUID Generator](https://acrafto.com/de/uuid-generator/) ([Markdown](https://acrafto.com/de/uuid-generator/index.md))
- Français (fr): [Générateur UUID](https://acrafto.com/fr/generateur-uuid/) ([Markdown](https://acrafto.com/fr/generateur-uuid/index.md))
- Español (es): [Generador de UUID](https://acrafto.com/es/generador-uuid/) ([Markdown](https://acrafto.com/es/generador-uuid/index.md))
- Italiano (it): [Generatore UUID](https://acrafto.com/it/generatore-uuid/) ([Markdown](https://acrafto.com/it/generatore-uuid/index.md))
- Português (pt): [Gerador de UUID](https://acrafto.com/pt/gerador-uuid/) ([Markdown](https://acrafto.com/pt/gerador-uuid/index.md))
- Nederlands (nl): [UUID generator](https://acrafto.com/nl/uuid-generator/) ([Markdown](https://acrafto.com/nl/uuid-generator/index.md))
- Polski (pl): [Generator UUID](https://acrafto.com/pl/generator-uuid/) ([Markdown](https://acrafto.com/pl/generator-uuid/index.md))
- Magyar (hu): [UUID generátor](https://acrafto.com/hu/uuid-generator/) ([Markdown](https://acrafto.com/hu/uuid-generator/index.md))
- Ελληνικά (el): [Γεννήτρια UUID](https://acrafto.com/el/gennitria-uuid/) ([Markdown](https://acrafto.com/el/gennitria-uuid/index.md))
- Български (bg): [UUID генератор](https://acrafto.com/bg/uuid-generator/) ([Markdown](https://acrafto.com/bg/uuid-generator/index.md))
- Hrvatski (hr): [Generator UUID](https://acrafto.com/hr/generator-uuid/) ([Markdown](https://acrafto.com/hr/generator-uuid/index.md))
- Slovenščina (sl): [UUID generator](https://acrafto.com/sl/generator-uuid/) ([Markdown](https://acrafto.com/sl/generator-uuid/index.md))
- Eesti (et): [UUID generaator](https://acrafto.com/et/uuid-generaator/) ([Markdown](https://acrafto.com/et/uuid-generaator/index.md))
- Latviešu (lv): [UUID ģenerators](https://acrafto.com/lv/uuid-generator/) ([Markdown](https://acrafto.com/lv/uuid-generator/index.md))
- Lietuvių (lt): [UUID generatorius](https://acrafto.com/lt/uuid-generatorius/) ([Markdown](https://acrafto.com/lt/uuid-generatorius/index.md))
- Svenska (sv): [UUID-generator](https://acrafto.com/sv/uuid-generator/) ([Markdown](https://acrafto.com/sv/uuid-generator/index.md))
- Dansk (da): [UUID generator](https://acrafto.com/da/uuid-generator/) ([Markdown](https://acrafto.com/da/uuid-generator/index.md))
- Suomi (fi): [UUID-generaattori](https://acrafto.com/fi/uuid-generaattori/) ([Markdown](https://acrafto.com/fi/uuid-generaattori/index.md))
- Norsk (no): [UUID-generator](https://acrafto.com/no/uuid-generator/) ([Markdown](https://acrafto.com/no/uuid-generator/index.md))
- Українська (uk): [Генератор UUID](https://acrafto.com/uk/henerator-uuid/) ([Markdown](https://acrafto.com/uk/henerator-uuid/index.md))
- Русский (ru): [Генератор UUID](https://acrafto.com/ru/generator-uuid/) ([Markdown](https://acrafto.com/ru/generator-uuid/index.md))
- Српски (sr): [UUID generator](https://acrafto.com/sr/uuid-generator/) ([Markdown](https://acrafto.com/sr/uuid-generator/index.md))
- Македонски (mk): [UUID генератор](https://acrafto.com/mk/uuid-generator/) ([Markdown](https://acrafto.com/mk/uuid-generator/index.md))
- Bosanski (bs): [Generator UUID-a](https://acrafto.com/bs/generator-uuid/) ([Markdown](https://acrafto.com/bs/generator-uuid/index.md))
- Shqip (sq): [Gjenerator UUID](https://acrafto.com/sq/gjenerator-uuid/) ([Markdown](https://acrafto.com/sq/gjenerator-uuid/index.md))
- Türkçe (tr): [UUID oluşturucu](https://acrafto.com/tr/uuid-uretici/) ([Markdown](https://acrafto.com/tr/uuid-uretici/index.md))
- 日本語 (ja): [UUID生成ツール](https://acrafto.com/ja/uuid-generator/) ([Markdown](https://acrafto.com/ja/uuid-generator/index.md))
- 한국어 (ko): [UUID 생성기](https://acrafto.com/ko/uuid-generator/) ([Markdown](https://acrafto.com/ko/uuid-generator/index.md))
- العربية (ar): [مولد UUID](https://acrafto.com/ar/uuid-generator/) ([Markdown](https://acrafto.com/ar/uuid-generator/index.md))
- हिन्दी (hi): [UUID जनरेटर](https://acrafto.com/hi/uuid-generator/) ([Markdown](https://acrafto.com/hi/uuid-generator/index.md))
- Bahasa Indonesia (id): [Generator UUID](https://acrafto.com/id/generator-uuid/) ([Markdown](https://acrafto.com/id/generator-uuid/index.md))
- Tiếng Việt (vi): [Trình tạo UUID](https://acrafto.com/vi/uuid-generator/) ([Markdown](https://acrafto.com/vi/uuid-generator/index.md))
- ไทย (th): [สร้าง UUID](https://acrafto.com/th/uuid-generator/) ([Markdown](https://acrafto.com/th/uuid-generator/index.md))
- עברית (he): [מחולל UUID](https://acrafto.com/he/uuid-generator/) ([Markdown](https://acrafto.com/he/uuid-generator/index.md))