# Generator UUID

> Wygeneruj UUID online za darmo – wszystkie wersje v1, v3-v7, nawet tysiące naraz. Działa w przeglądarce, bez rejestracji i limitów.

URL: https://acrafto.com/pl/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.

## Co to jest UUID?

UUID (Universally Unique Identifier) to 128-bitowy identyfikator używany w systemach komputerowych do unikalnej identyfikacji informacji. UUID jest standaryzowany zgodnie z RFC 4122 i dzięki swojej ogromnej entropii gwarantuje praktycznie zerowe prawdopodobieństwo kolizji – to znaczy, że dwa niezależnie wygenerowane UUID będą prawie na pewno unikalne.

UUID ma standardowy format: `xxxxxxxx-xxxx-Mxxx-Nxxx-xxxxxxxxxxxx`, gdzie każdy `x` to cyfra szesnastkowa (0-9, a-f), `M` oznacza wersję UUID, a `N` oznacza wariant.

## Wersje UUID

### UUID v1 (znacznik czasu + adres MAC)

UUID v1 jest oparte na aktualnym znaczniku czasu (timestamp) i losowej wartości (w przeglądarce zamiast adresu MAC). Wykorzystuje 100-nanosekundowe interwały od 15 października 1582 roku (kalendarz gregoriański).

**Zastosowanie:**

- Sytuacje, gdy potrzebujesz chronologicznego sortowania UUID
- Debugowanie i logowanie (UUID zawiera informację o czasie utworzenia)
- Systemy rozproszone z synchronizacją czasową

**Przykład:** `6ba7b810-9dad-11d1-80b4-00c04fd430c8`

**Zalety:**

- UUID można sortować chronologicznie według czasu utworzenia
- Przydatne do audytu i debugowania
- Zawiera informację o znaczniku czasu

**Wady:**

- Potencjalne ryzyko bezpieczeństwa – zawiera znacznik czasu
- W przeglądarce nie zawiera prawdziwego adresu MAC (zastąpionej wartością losową)
- Słaba lokalizacja DB (znacznik czasu jest w bitach niskiego rzędu)

### UUID v3 (hash MD5)

UUID v3 jest generowane za pomocą hasha MD5 przestrzeni nazw UUID i nazwy. Jest deterministyczne – ta sama przestrzeń nazw + nazwa zawsze utworzą to samo UUID.

**Zastosowanie:**

- Konwersja URL, nazw DNS lub innych identyfikatorów na UUID
- Sytuacje, gdy potrzebujesz powtarzalnego UUID
- Mapowanie między różnymi systemami identyfikacji

**Przykład:** `a3bb189e-8bf9-3888-9912-ace4e6543002`

**Zalety:**

- Deterministyczne (ten sam wejście = ten sam wynik)
- Idealne do konwersji znanych identyfikatorów
- Brak kolizji dla różnych wejść

**Wady:**

- MD5 to przestarzały algorytm (preferuj v5)
- Wymaga przestrzeni nazw i nazwy
- Nie można odzyskać oryginalnego wejścia

### UUID v4 (losowe) - ZALECANE

Najczęściej używana wersja UUID. UUID v4 jest generowane czysto losowo za pomocą kryptograficznie bezpiecznego generatora liczb losowych (`crypto.getRandomValues()`).

**Zastosowanie:**

- Klucze główne baz danych
- Identyfikatory sesji (session IDs)
- Unikalne nazwy plików
- Tokeny API
- Ogólne zastosowania, gdzie potrzebujesz gwarantowanie unikalnego ID

**Przykład:** `f47ac10b-58cc-4372-a567-0e02b2c3d479`

**Zalety:**

- Maksymalna entropia i bezpieczeństwo
- Brak zależności od czasu lub parametrów systemowych
- Najprostsza implementacja

**Prawdopodobieństwo kolizji:** Przy generowaniu 1 miliarda UUID na sekundę przez 100 lat szansa na kolizję wynosi około 0,00000006%.

### UUID v5 (hash SHA-1)

UUID v5 jest takie samo jak v3, ale używa SHA-1 zamiast MD5. Nowocześniejsza i bezpieczniejsza alternatywa dla v3.

**Zastosowanie:**

- Takie samo jak v3, ale z lepszym bezpieczeństwem
- Preferowane przed v3 w nowych projektach
- Generowanie UUID z URL, nazw DNS, OID, X.500 DN

**Przykład:** `886313e1-3b8a-5372-9b90-0c9aee199e5d`

**Zalety:**

- Deterministyczne
- SHA-1 jest bardziej odporne niż MD5
- Odpowiednie do mapowania między systemami

**Wady:**

- SHA-1 również jest uważane za przestarzałe (ale nadal bezpieczniejsze niż MD5)
- Wymaga przestrzeni nazw i nazwy

### UUID v6 (posortowany znacznik czasu)

UUID v6 to ulepszona wersja v1 z przestawionymi bitami czasowymi dla lepszego indeksowania w bazach danych. Zaprojektowana, aby rozwiązać problemy z lokalizacją w bazach danych.

**Zastosowanie:**

- Klucze główne baz danych z sortowaniem czasowym
- Systemy wymagające chronologicznego sortowania i wydajności DB
- Nowocześniejsza alternatywa dla v1

**Przykład:** `1ec9414c-232a-6b00-b3c8-9e6bdeced846`

**Zalety:**

- Lepsza lokalizacja DB niż v1 (znacznik czasu w bitach wysokiego rzędu)
- Chronologiczne sortowanie
- Kompatybilne ze standardem UUID

**Wady:**

- Mniej używane niż v1/v4
- Nadal zawiera informacje o czasie (ryzyko bezpieczeństwa)

### UUID v7 (znacznik czasu Unix)

UUID v7 używa znacznika czasu Unix (milisekundy od 1970) + losowe bity. Najnowsza wersja UUID z najlepszą lokalizacją DB.

**Zastosowanie:**

- Nowoczesne klucze główne baz danych
- Systemy wymagające wydajności + sortowania czasowego
- Zastępuje v1/v6 w nowych projektach

**Przykład:** `017f22e2-79b0-7cc3-98c4-dc0c0c07398f`

**Zalety:**

- Najlepsza lokalizacja DB spośród wszystkich wersji
- Znacznik czasu Unix jest standardowy
- Łączy zalety losowości i sortowania czasowego

**Wady:**

- Stosunkowo nowa specyfikacja (RFC 4122bis)
- Mniej obsługiwane w starszych systemach

## Której wersji UUID użyć?

### Przewodnik decyzyjny

**Potrzebujesz maksymalnego bezpieczeństwa i losowości?** → Użyj **UUID v4** (najczęstszy wybór)

**Potrzebujesz sortowania czasowego i wydajności DB?** → Użyj **UUID v7** (nowoczesne) lub **UUID v6** (standard)

**Potrzebujesz powtarzalnego UUID z istniejących identyfikatorów?** → Użyj **UUID v5** (SHA-1) lub **UUID v3** (MD5, starsze)

**Potrzebujesz znacznika czasu i śladu audytu?** → Użyj **UUID v1** (starsze, gorsza wydajność DB)

### Bazy danych

**Dla nowych projektów:** UUID v7 lub v4

- **v7** jest idealne do sortowania czasowego + wydajności
- **v4** dla maksymalnej losowości bez informacji o czasie

**Dla starszych systemów:** UUID v1 lub v6

- **v6** ma lepszą lokalizację DB niż v1
- **v1** jest szeroko obsługiwane

**Zalety UUID jako klucza głównego:**

- **Globalna unikalność** – Możesz łączyć dane z różnych baz danych bez konfliktu
- **Bezpieczeństwo** – W przeciwieństwie do sekwencyjnych ID (1, 2, 3…) nie można odgadnąć kolejnych wartości
- **Systemy rozproszone** – UUID można generować niezależnie na wielu serwerach bez koordynacji
- **Łączenie baz danych** – Podczas scalania dwóch baz danych nie powstają konflikty

**Wady:**

- Większy rozmiar (16 bajtów vs 4-8 bajtów dla liczb całkowitych)
- Wolniejsze indeksowanie w niektórych bazach danych (używaj v6/v7 dla lepszej wydajności)
- Mniej czytelne dla człowieka

### API i usługi webowe

- **REST API** – Unikalne identyfikatory dla zasobów
- **GraphQL** – Globalne identyfikatory dla węzłów
- **Webhooki** – Śledzenie żądań i odpowiedzi
- **Tokeny** – Identyfikatory sesji, tokeny odświeżania

### Pliki i przechowywanie

- **Nazwy plików** – Zapobieganie kolizjom podczas przesyłania
- **S3/Cloud Storage** – Unikalne ścieżki do obiektów
- **Klucze pamięci podręcznej** – Identyfikatory w systemach pamięci podręcznej

### Aplikacje frontendowe

- **Komponenty React/Vue** – Unikalne klucze dla list
- **Tymczasowe ID** – ID przed zapisaniem do bazy danych
- **Pamięć lokalna** – Klucze dla zapisanych danych
- **Aplikacje offline-first** – Generowanie ID bez połączenia z serwerem

## Zaawansowane funkcje generatora

### Generowanie UUID z niestandardowym czasem

Dla wersji opartych na czasie (v1, v6, v7) możesz wybrać dowolny znacznik czasu za pomocą selektora daty i godziny. Jest to przydatne do:

**Testowanie:**

- Symulacja UUID utworzonych w przeszłości
- Testowanie sortowania czasowego w bazach danych
- Reprodukcja UUID do debugowania

**Migracja danych:**

- Generowanie UUID z historycznymi znacznikami czasu
- Uzupełnianie danych z poprawnymi wartościami znacznika czasu
- Import danych z różnych okresów czasu

**Audyt i zgodność:**

- Rekonstrukcja UUID według czasu powstania rekordu
- Retroaktywne generowanie identyfikatorów

**Przykład użycia:**

1. Wybierz wersję v1, v6 lub v7
2. Ustaw datę i godzinę za pomocą selektora daty i godziny
3. Wygeneruj UUID z własnym znacznikiem czasu

### Hash-based UUID (v3, v5)

Dla deterministycznych UUID możesz użyć wersji v3 (MD5) lub v5 (SHA-1):

**Jak używać:**

1. Wybierz przestrzeń nazw według typu swojego identyfikatora
2. Wprowadź nazwę/wartość
3. Wygeneruj UUID

**Przykłady:**

| Przestrzeń nazw | Nazwa (wejście) | Użycie |
| --- | --- | --- |
| DNS | `example.com` | Konwersja nazwy domeny na UUID |
| DNS | `google.com` | Każda strona ma unikalne UUID |
| URL | `https://example.com/page` | Konwersja URL na UUID |
| URL | `https://api.example.com/users/123` | Punkt końcowy API jako UUID |
| OID | `1.3.6.1.4.1.343` | Identyfikator obiektu na UUID |
| X.500 | `CN=John Doe,O=Company` | Nazwa wyróżniająca na UUID |

**Ważne cechy:**

- ✅ **Deterministyczne**: To samo wejście = zawsze to samo UUID
- ✅ **Powtarzalne**: Możesz ponownie utworzyć UUID w dowolnym momencie
- ✅ **Spójne**: To samo UUID w różnych systemach
- ❌ **Nie można dekodować**: Z UUID nie można odzyskać oryginalnej nazwy
- ℹ️ **Jedno UUID**: Dla v3/v5 zawsze generuje się tylko jedno UUID (to samo wejście = ten sam wynik)

**Praktyczne zastosowanie:**

```
// Przykład: Konwersja URL na UUID v5
Namespace: URL
Nazwa: https://example.com/api/users/123
Wynik: 886313e1-3b8a-5372-9b90-0c9aee199e5d

// To samo wejście = zawsze to samo UUID
Namespace: DNS
Nazwa: google.com
Wynik: zawsze to samo UUID dla google.com
```

## Jak bezpiecznie używać UUID?

### Bezpieczeństwo kryptograficzne

Nasz generator używa `crypto.getRandomValues()`, który jest kryptograficznie bezpiecznym generatorem liczb losowych. W przeciwieństwie do `Math.random()`, który jest przewidywalny i nieodpowiedni do celów bezpieczeństwa, `crypto.getRandomValues()` zapewnia prawdziwą entropię odpowiednią do:

- Generowania tokenów bezpieczeństwa
- Identyfikatorów sesji
- Kluczy API
- Aplikacji kryptograficznych

### Porównanie wersji UUID

| Wersja | Podstawa | Kolizja | Sortowanie czasowe | Wydajność DB | Zastosowanie |
| --- | --- | --- | --- | --- | --- |
| v1 | Znacznik czasu + MAC | Niska | ✅ Tak | ❌ Gorsza | Starsze, audyt |
| v3 | Hash MD5 | Brak (deterministyczne) | ❌ Nie | ⚠️ Średnia | Konwersje (starsze) |
| v4 | Losowe | Ekstremalnie niska | ❌ Nie | ⚠️ Średnia | Ogólne zastosowanie |
| v5 | Hash SHA-1 | Brak (deterministyczne) | ❌ Nie | ⚠️ Średnia | Konwersje (zalecane) |
| v6 | Posortowany znacznik czasu | Niska | ✅ Tak | ✅ Lepsza | Nowoczesne DB z czasem |
| v7 | Znacznik czasu Unix | Niska | ✅ Tak | ✅ Najlepsza | Nowe projekty |

### UUID a inne identyfikatory

| Typ | Rozmiar | Kolizja | Sortowanie czasowe | Zastosowanie |
| --- | --- | --- | --- | --- |
| ID auto-inkrementowane | 4-8 bajtów | Gwarantowanie unikalne w tabeli | ❌ | Proste aplikacje, lokalne DB |
| UUID v4 | 16 bajtów | Praktycznie niemożliwa | ❌ | Systemy rozproszone, API |
| UUID v7 | 16 bajtów | Praktycznie niemożliwa | ✅ | Nowoczesne DB z wydajnością |
| ULID | 16 bajtów | Praktycznie niemożliwa | ✅ | UUID + sortowanie leksykograficzne |
| Snowflake ID | 8 bajtów | Gwarantowanie unikalne przy prawidłowej konfiguracji | ✅ | Twitter, systemy rozproszone |
| NanoID | Konfigurowalna | Zależy od długości | ❌ | ID przyjazne dla URL |

## Implementacja w różnych językach

### JavaScript/TypeScript

```
// UUID v4 - Najprostszy sposób (nowoczesne przeglądarki)
const uuid = crypto.randomUUID();

// UUID v4 - Implementacja ręczna
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 - Zalecane dla baz danych
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();
```

## Najlepsze praktyki

### Zapisywanie UUID w bazie danych

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

**Wskazówka:** W MySQL przechowuj UUID jako `BINARY(16)` zamiast `CHAR(36)`, aby zaoszczędzić miejsce i przyspieszyć indeksowanie.

### Walidacja 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);
}
```

### Konwersja UUID

```
// Usunięcie myślników
const compact = uuid.replace(/-/g, '');

// Dodanie myślników z powrotem
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('-');
}
```

## Rozwiązywanie problemów (Troubleshooting)

### UUID v3/v5 nie działa

**Problem:** Po wybraniu v3 lub v5 nic się nie generuje

**Rozwiązanie:**

1. ✅ Sprawdź, czy **wypełniłeś pole “Nazwa”** - jest ono obowiązkowe!
2. ✅ Wybierz odpowiednią przestrzeń nazw według typu swojego wejścia
3. ✅ Przykłady prawidłowych wejść:
   - DNS: `example.com`, `google.com`
   - URL: `https://example.com/page`
   - Dowolny tekst: `moja-aplikacja-v1`

**Wskazówka:** Spróbuj najpierw prostej wartości, np. `test` i przestrzeń nazw DNS.

### Czasowe UUID (v1, v6, v7) ma dziwny czas

**Problem:** Wygenerowane UUID ma nieoczekiwany znacznik czasu

**Rozwiązanie:**

1. ✅ Sprawdź selektor daty i godziny - czy ustawiono prawidłowy czas?
2. ✅ Selektor daty i godziny używa Twojej lokalnej strefy czasowej
3. ✅ Pozostaw selektor daty i godziny pusty, aby użyć aktualnego czasu

### UUID nie można skopiować

**Problem:** Przycisk “Kopiuj wszystko” nie działa

**Rozwiązanie:**

1. ✅ Sprawdź, czy wygenerowałeś UUID (nie są puste)
2. ✅ Niektóre przeglądarki wymagają HTTPS dla API schowka
3. ✅ Alternatywnie wybierz tekst w polu tekstowym i skopiuj ręcznie (Ctrl+C)

## Często zadawane pytania (FAQ)

### Czy może dojść do kolizji UUID?

Teoretycznie tak, ale prawdopodobieństwo jest astronomicznie małe. Przy generowaniu 1 miliarda UUID v4 na sekundę przez 100 lat szansa na kolizję wynosi około 0,00000006%. W praktyce kolizja nigdy się nie zdarzy.

### Czy UUID jest odpowiednie jako klucz główny w bazie danych?

Zależy to od przypadku użycia. UUID jest idealne dla systemów rozproszonych i sytuacji, gdy potrzebujesz globalnej unikalności. Dla prostych aplikacji z jedną bazą danych auto-inkrement może być bardziej efektywny.

### Czy UUID wygenerowane przez to narzędzie są bezpieczne?

Tak, używamy Web Crypto API (\`crypto.getRandomValues()\`), które dostarcza kryptograficznie bezpiecznych losowych wartości. Wszystko odbywa się lokalnie w Twojej przeglądarce.

### Jaka jest różnica między wersjami UUID?

\- \*\*v1\*\*: Znacznik czasu + MAC/losowe - sortowanie chronologiczne, gorsza wydajność DB - \*\*v3/v5\*\*: Oparte na hashach - deterministyczne, do konwersji znanych identyfikatorów - \*\*v4\*\*: Losowe - najbezpieczniejsze, najczęściej używane - \*\*v6\*\*: Posortowany znacznik czasu - lepsza wydajność DB niż v1 - \*\*v7\*\*: Znacznik czasu Unix - najlepsza wydajność DB + sortowanie czasowe

### Którą wersję UUID powinienem użyć?

W większości przypadków użyj \*\*v4\*\* (losowe). Dla baz danych z sortowaniem czasowym użyj \*\*v7\*\* (nowoczesne) lub \*\*v6\*\* (standard). Do konwersji znanych identyfikatorów (URL, DNS) użyj \*\*v5\*\* (SHA-1).

### Czy mogę używać UUID do tokenów i kluczy API?

UUID v4 nadaje się do identyfikatorów sesji i podobnych tokenów. Dla kluczy API rozważ użycie dłuższych losowych ciągów (np. wartości 256-bitowych) lub specjalistycznych bibliotek.

### Jak duże są UUID?

UUID ma 128 bitów (16 bajtów). W formacie ciągu z myślnikami zajmuje 36 znaków. Bez myślników 32 znaki szesnastkowe.

## Alternatywy dla UUID

### ULID (Universally Unique Lexicographically Sortable Identifier)

- 128-bitowy identyfikator (tak samo jak UUID)
- Sortowalny leksykograficznie według czasu utworzenia
- Bardziej kompaktowa reprezentacja (26 znaków zamiast 36)
- Kodowanie base32 bez rozróżniania wielkości liter

**Przykład:** `01ARZ3NDEKTSV4RRFFQ69G5FAV`

### NanoID

- Mniejszy rozmiar niż UUID (standardowo 21 znaków)
- Przyjazny dla URL (bez znaków specjalnych)
- Szybsze generowanie
- Konfigurowalna długość i alfabet

**Przykład:** `V1StGXR8_Z5jdHi6B-myT`

### Snowflake ID (Twitter)

- 64-bitowy identyfikator (mniejszy niż UUID)
- Sortowalny czasowo
- Zawiera ID pracownika i numer sekwencyjny
- Wymaga scentralizowanej konfiguracji

**Przykład:** `1234567890123456789`

## Wydajność i optymalizacja

### Szybkość generowania

Nasz generator potrafi wygenerować:

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

### Wskazówki dotyczące wydajności

1. **Generowanie wsadowe** – Jeśli potrzebujesz wielu UUID, generuj je jednocześnie zamiast pojedynczo
2. **Zapisywanie w DB** – Indeksuj kolumny UUID dla szybkiego wyszukiwania
3. **Kompresja** – Przechowuj UUID w formie binarnej (16 bajtów) zamiast ciągu (36 bajtów)
4. **Buforowanie** – W niektórych przypadkach możesz wstępnie wygenerować i buforować UUID

## Dla programistów

### Struktura UUID v4

```
xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx
|        |    |    |    |
|        |    |    |    └─ 48 bitów losowych danych (node)
|        |    |    └────── 16 bitów losowych danych z wariantem (clock_seq)
|        |    └─────────── 12 bitów losowych danych + 4 bity wersji (time_hi_and_version)
|        └──────────────── 16 bitów losowych danych (time_mid)
└───────────────────────── 32 bity losowych danych (time_low)
```

- Wersja (4 bity): zawsze `0100` (binarnie) = `4` (szesnastkowo)
- Wariant (2-3 bity): zawsze `10` (binarnie) dla RFC 4122

### Testowanie UUID

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

## Aspekty bezpieczeństwa

### Czego nie robić z UUID

❌ **Nie używaj UUID v1 do wrażliwych aplikacji** – Zawiera znacznik czasu, co może stanowić ryzyko bezpieczeństwa

❌ **Nie używaj `Math.random()` do generowania UUID** – Nie jest kryptograficznie bezpieczny

❌ **Nie polegaj na UUID do autoryzacji** – UUID można odgadnąć (choć z ekstremalnie małym prawdopodobieństwem)

❌ **Nie przechowuj UUID w ciasteczkach bez szyfrowania** – Użyj podpisanych ciasteczek lub JWT

### Co robić

✅ **Używaj UUID v4 w większości przypadków** – Najwyższa entropia i bezpieczeństwo

✅ **Łącz UUID z innymi środkami bezpieczeństwa** – Do zarządzania sesjami użyj HTTPS, ciasteczek HttpOnly i krótkiej daty ważności

✅ **Waliduj UUID na serwerze** – Zawsze sprawdzaj format i wersję UUID

✅ **Używaj kryptograficznie bezpiecznych źródeł losowości** – `crypto.getRandomValues()` w przeglądarce, `/dev/urandom` w systemie Linux

## Ciekawostki

- **Liczba możliwych UUID v4:** 2^122 ≈ 5.3 × 10^36 (340 undecillionów)
- **Potrzebna kolizja:** Aby uzyskać 50% szansy na kolizję, musisz wygenerować 2.71 × 10^18 UUID (2.71 kwintylionów)
- **Rozmiar wszystkich możliwych UUID:** Gdybyśmy każde UUID przechowywali jako 16 bajtów, cała przestrzeń zajęłaby 85 zettabajtów (85 miliardów terabajtów)
- **Pochodzenie:** UUID zostało zestandaryzowane jako część DCE (Distributed Computing Environment) w 1990 roku

## 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))
- Română (ro): [Generator UUID](https://acrafto.com/ro/generator-uuid/) ([Markdown](https://acrafto.com/ro/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))