UUID Ģenerators

Kas ir UUID?

UUID (Universāli Unikāls Identifikators) ir 128 bitu identifikators, ko izmanto datorsistēmās informācijas unikālai identificēšanai. UUID ir standartizēts saskaņā ar RFC 4122, un, pateicoties tā milzīgajai entropijai, garantē praktiski nulles sadursmes iespējamību – tas nozīmē, ka divi neatkarīgi ģenerēti UUID gandrīz noteikti būs unikāli.

UUID ir standarta formāts: xxxxxxxx-xxxx-Mxxx-Nxxx-xxxxxxxxxxxx, kur katrs x ir heksadecimāls cipars (0-9, a-f), M apzīmē UUID versiju un N apzīmē variantu.

UUID versijas

UUID v1 (Laika zīmogs + MAC adrese)

UUID v1 pamatā ir pašreizējais laika zīmogs un nejauša vērtība (pārlūkprogrammā MAC adreses vietā). Tas izmanto 100 nanosekunžu intervālus kopš 1582. gada 15. oktobra (Gregora kalendārs).

Lietojums:

• Situācijas, kad nepieciešama hronoloģiska UUID kārtošana
• Atkļūdošana un žurnālēšana (UUID satur informāciju par izveides laiku)
• Izplatītas sistēmas ar laika sinhronizāciju

Piemērs: 6ba7b810-9dad-11d1-80b4-00c04fd430c8

Priekšrocības:

• UUID var sakārtot hronoloģiski pēc izveides laika
• Noderīgi auditam un atkļūdošanai
• Satur laika zīmoga informāciju

Trūkumi:

• Potenciāls drošības risks – satur laika zīmogu
• Pārlūkprogrammā nesatur reālu MAC adresi (aizstāta ar nejaušu vērtību)
• Slikta DB lokalitāte (laika zīmogs ir zemāko bitu daļā)

UUID v3 (MD5 jaucējvērtība)

UUID v3 tiek ģenerēts, izmantojot MD5 jaucējvērtību no UUID vārdtelpas un nosaukuma. Deterministisks – tā pati vārdtelpa + nosaukums vienmēr radīs to pašu UUID.

Lietojums:

• URL, DNS nosaukumu vai citu identifikatoru pārveidošana par UUID
• Situācijas, kad nepieciešams reproducējams UUID
• Kartēšana starp dažādām identifikācijas sistēmām

Piemērs: a3bb189e-8bf9-3888-9912-ace4e6543002

Priekšrocības:

• Deterministisks (tāda pati ievade = tā pati izvade)
• Ideāli piemērots zināmu identifikatoru konvertēšanai
• Nav sadursmes dažādām ievadēm

Trūkumi:

• MD5 ir novecojis algoritms (dodiet priekšroku v5)
• Nepieciešama vārdtelpa un nosaukums
• Nevar atgūt sākotnējo ievadi

UUID v4 (Nejauša) - IETEICAMS

Visbiežāk izmantotā UUID versija. UUID v4 tiek ģenerēts tīri nejauši, izmantojot kriptogrāfiski drošu nejaušo skaitļu ģeneratoru (crypto.getRandomValues()).

Lietojums:

• Datubāzes primārās atslēgas
• Sesiju identifikatori (session IDs)
• Unikāli failu nosaukumi
• API tokeni
• Vispārīgiem mērķiem, kur nepieciešams garantēti unikāls ID

Piemērs: f47ac10b-58cc-4372-a567-0e02b2c3d479

Priekšrocības:

• Maksimāla entropija un drošība
• Nav atkarības no laika vai sistēmas parametriem
• Vienkāršākā implementācija

Sadursmes iespējamība: Ģenerējot 1 miljardu UUID sekundē 100 gadu garumā, sadursmes iespējamība ir aptuveni 0,00000006%.

UUID v5 (SHA-1 jaucējvērtība)

UUID v5 ir tāds pats kā v3, bet izmanto SHA-1 MD5 vietā. Modernāka un drošāka alternatīva v3.

Lietojums:

• Tāds pats kā v3, bet ar labāku drošību
• Dodots priekšroka v3 jaunām projektēšanas vajadzībām
• UUID ģenerēšana no URL, DNS nosaukumiem, OID, X.500 DN

Piemērs: 886313e1-3b8a-5372-9b90-0c9aee199e5d

Priekšrocības:

• Deterministisks
• SHA-1 ir robustāks par MD5
• Piemērots kartēšanai starp sistēmām

Trūkumi:

• SHA-1 arī tiek uzskatīts par novecojušu (bet joprojām drošāks par MD5)
• Nepieciešama vārdtelpa un nosaukums

UUID v6 (Sakārtots laika zīmogs)

UUID v6 ir uzlabota v1 versija ar pārkārtotiem laika bitiem labākai datubāzes indeksēšanai. Izstrādāts, lai risinātu lokalitātes problēmas datubāzēs.

Lietojums:

• Datubāzes primārās atslēgas ar laika kārtošanu
• Sistēmas, kas prasa hronoloģisku kārtošanu un DB veiktspēju
• Modernāka alternatīva v1

Piemērs: 1ec9414c-232a-6b00-b3c8-9e6bdeced846

Priekšrocības:

• Labāka DB lokalitāte nekā v1 (laika zīmogs augstākās kārtas bitos)
• Hronoloģiska kārtošana
• Savietojams ar UUID standartu

Trūkumi:

• Retāk izmantots nekā v1/v4
• Joprojām satur laika informāciju (drošības risks)

UUID v7 (Unix laika zīmogs)

UUID v7 izmanto Unix laika zīmogu (milisekundes kopš 1970. gada) + nejaušus bitus. Jaunākā UUID versija ar labāko DB lokalitāti.

Lietojums:

• Modernās datubāzes primārās atslēgas
• Sistēmas, kas prasa veiktspēju + laika kārtošanu
• V1/v6 aizvietošana jaunos projektos

Piemērs: 017f22e2-79b0-7cc3-98c4-dc0c0c07398f

Priekšrocības:

• Labākā DB lokalitāte no visām versijām
• Unix laika zīmogs ir standarts
• Apvieno nejaušības un laika kārtošanas priekšrocības

Trūkumi:

• Salīdzinoši jauna specifikācija (RFC 4122bis)
• Mazāk atbalstīta mantotajās sistēmās

Kuru UUID versiju izmantot?

Lēmumu pieņemšanas ceļvedis

Vai nepieciešama maksimāla drošība un nejaušība? → Izmantojiet UUID v4 (visbiežākā izvēle)

Vai nepieciešama laika kārtošana un DB veiktspēja? → Izmantojiet UUID v7 (moderna) vai UUID v6 (standarta)

Vai nepieciešams reproducējams UUID no esošajiem identifikatoriem? → Izmantojiet UUID v5 (SHA-1) vai UUID v3 (MD5, novecojusi)

Vai nepieciešams laika zīmogs un audita izsekojamība? → Izmantojiet UUID v1 (novecojusi, sliktāka DB veiktspēja)

Datubāzes

Jauniem projektiem: UUID v7 vai v4

• v7 ir ideāls laika kārtošanai + veiktspējai
• v4 maksimālai nejaušībai bez laika informācijas

Mantotām sistēmām: UUID v1 vai v6

• v6 ir labāka DB lokalitāte nekā v1
• v1 ir plaši atbalstīta

UUID kā primārās atslēgas priekšrocības:

• Globāla unikalitāte – Varat apvienot datus no dažādām datubāzēm bez konfliktiem
• Drošība – Atšķirībā no secīgiem ID (1, 2, 3…), nākamās vērtības nevar uzminēt
• Izplatītas sistēmas – UUID var ģenerēt neatkarīgi vairākos serveros bez koordinācijas
• Datubāzu apvienošana – Apvienojot divas datubāzes, nerodas konflikti

Trūkumi:

• Lielāks izmērs (16 baiti pret 4-8 baitiem veselam skaitlim)
• Lēnāka indeksēšana dažās datubāzēs (izmantojiet v6/v7 labākai veiktspējai)
• Mazāk lasāms cilvēkam

API un tīmekļa pakalpojumi

• REST API – Unikāli resursu identifikatori
• GraphQL – Globāli mezglu identifikatori
• Webhooki – Pieprasījumu un atbilžu izsekošana
• Tokeni – Sesiju ID, atsvaidzināšanas tokeni

Faili un glabāšana

• Failu nosaukumi – Sadursmju novēršana augšupielādes laikā
• S3/Mākoņglabātuve – Unikāli ceļi uz objektiem
• Kešatmiņas atslēgas – Identifikatori kešatmiņas sistēmās

Frontend lietojumprogrammas

• React/Vue komponentes – Unikālas atslēgas sarakstiem
• Pagaidu ID – ID pirms saglabāšanas datubāzē
• Lokālā glabātuve – Atslēgas saglabātajiem datiem
• Pirmkārt bezsaistes lietojumprogrammas – ID ģenerēšana bez savienojuma ar serveri

Ģeneratora uzlabotās funkcijas

UUID ģenerēšana ar pielāgotu laiku

Laika bāzes versijām (v1, v6, v7) varat izvēlēties jebkuru laika zīmogu, izmantojot datuma un laika izvēles rīku. Tas ir noderīgi:

Testēšana:

• Pagātnē izveidotu UUID simulācija
• Laika kārtošanas testēšana datubāzēs
• UUID reproducēšana atkļūdošanai

Datu migrācija:

• UUID ģenerēšana ar vēsturiskiem laika zīmogiem
• Datu papildināšana ar pareizām laika zīmogu vērtībām
• Datu importēšana no dažādiem laika periodiem

Audits un atbilstība:

• UUID rekonstrukcija pēc ieraksta izveides laika
• Retroaktīva identifikatoru ģenerēšana

Lietošanas piemērs:

1. Izvēlieties versiju v1, v6 vai v7
2. Iestatiet datumu un laiku, izmantojot datuma un laika izvēles rīku
3. Ģenerējiet UUID ar savu pielāgoto laika zīmogu

Uz jaucējvērtību balstīts UUID (v3, v5)

Deterministiskiem UUID varat izmantot versijas v3 (MD5) vai v5 (SHA-1):

Kā lietot:

1. Izvēlieties vārdtelpu atbilstoši jūsu identifikatora tipam
2. Ievadiet nosaukumu/vērtību
3. Ģenerējiet UUID

Piemēri:

Svarīgas īpašības:

• ✅ Deterministisks: Tāda pati ievade = vienmēr tas pats UUID
• ✅ Reproducējams: UUID var atkārtoti izveidot jebkurā laikā
• ✅ Konsekvents: Tas pats UUID dažādās sistēmās
• ❌ Nevar dekodēt: No UUID nevar atgūt sākotnējo nosaukumu
• ℹ️ Viens UUID: V3/v5 vienmēr tiek ģenerēts tikai viens UUID (tāda pati ievade = tā pati izvade)

Praktiskais lietojums:

// Piemērs: URL pārveidošana par UUID v5
Namespace: URL
Nosaukums: https://example.com/api/users/123
Rezultāts: 886313e1-3b8a-5372-9b90-0c9aee199e5d

// Tāda pati ievade = vienmēr tas pats UUID
Namespace: DNS
Nosaukums: google.com
Rezultāts: vienmēr tas pats UUID priekš google.com

Kā droši lietot UUID?

Kriptogrāfiskā drošība

Mūsu ģenerators izmanto crypto.getRandomValues(), kas ir kriptogrāfiski drošs nejaušo skaitļu ģenerators. Atšķirībā no Math.random(), kas ir paredzams un nederīgs drošības mērķiem, crypto.getRandomValues() nodrošina reālu entropiju, kas piemērota:

• Drošības tokenu ģenerēšanai
• Sesiju ID
• API atslēgas
• Kriptogrāfiskas lietojumprogrammas

UUID versiju salīdzinājums

UUID pret citiem identifikatoriem

Ieviešana dažādās valodās

JavaScript/TypeScript

// UUID v4 - Nejjednodušší způsob (moderní prohlížeče)
const uuid = crypto.randomUUID();

// UUID v4 - Manuální implementace
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 - Doporučeno pro databáze
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();

Labākā prakse

UUID glabāšana datubāzē

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

Padoms: MySQL saglabājiet UUID kā BINARY(16) CHAR(36) vietā, lai ietaupītu vietu un ātrāk indeksētu.

UUID validācija

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

UUID konvertēšana

// Odstranění pomlček
const compact = uuid.replace(/-/g, '');

// Přidání pomlček zpět
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('-');
}

Problēmu risināšana (Troubleshooting)

UUID v3/v5 nedarbojas

Problēma: Pēc v3 vai v5 izvēles nekas netiek ģenerēts

Risinājums:

1. ✅ Pārbaudiet, vai esat aizpildījis lauku “Nosaukums” – tas ir obligāts!
2. ✅ Izvēlieties pareizo vārdtelpu atbilstoši jūsu ievades veidam
3. ✅ Derīgu ievadu piemēri:
   • DNS: example.com, google.com
   • URL: https://example.com/page
   • Jebkurš teksts: mana-lietotne-v1

Padoms: Vispirms izmēģiniet vienkāršu vērtību, piemēram, test, un DNS vārdtelpu.

Laika UUID (v1, v6, v7) ir dīvains laiks

Problēma: Ģenerētajam UUID ir negaidīts laika zīmogs

Risinājums:

1. ✅ Pārbaudiet datuma un laika izvēles rīku – vai ir iestatīts pareizais laiks?
2. ✅ Datuma un laika izvēles rīks izmanto jūsu lokālo laika joslu
3. ✅ Atstājiet datuma un laika izvēles rīku tukšu pašreizējam laikam

UUID nevar nokopēt

Problēma: Poga “Kopēt visu” nedarbojas

Risinājums:

1. ✅ Pārbaudiet, vai esat ģenerējis UUID (tie nav tukši)
2. ✅ Dažas pārlūkprogrammas pieprasa HTTPS starpliktuves API
3. ✅ Alternatīvi atlasiet tekstu tekstlodziņā un kopējiet manuāli (Ctrl+C)

Biežāk uzdotie jautājumi (BUJ)

Alternatīvas UUID

ULID (Universāli Unikāls Leksikogrāfiski Kārtojams Identifikators)

• 128 bitu ID (tāpat kā UUID)
• Leksikogrāfiski kārtojams pēc izveides laika
• Kompaktāks attēlojums (26 rakstzīmes 36 vietā)
• Bezreģistra base32 kodējums

Piemērs: 01ARZ3NDEKTSV4RRFFQ69G5FAV

NanoID

• Mazāks izmērs nekā UUID (standartā 21 rakstzīme)
• URL-draudzīgs (bez speciālām rakstzīmēm)
• Ātrāka ģenerēšana
• Konfigurējams garums un alfabēts

Piemērs: V1StGXR8_Z5jdHi6B-myT

Snowflake ID (Twitter)

• 64 bitu ID (mazāks par UUID)
• Laika ziņā kārtojams
• Satur darbinieka ID un secības numuru
• Nepieciešama centralizēta konfigurācija

Piemērs: 1234567890123456789

Veiktspēja un optimizācija

Ģenerēšanas ātrums

Mūsu ģenerators spēj ģenerēt:

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

Veiktspējas padomi

1. Masveida ģenerēšana – Ja jums nepieciešami daudzi UUID, ģenerējiet tos visus uzreiz, nevis pa vienam
2. Glabāšana DB – Indeksējiet UUID kolonnas ātrai meklēšanai
3. Kompresija – Glabājiet UUID binārā formātā (16 baiti) virknes (36 baiti) vietā
4. Kešatmiņa – Dažos gadījumos varat iepriekš ģenerēt un kešot UUID

Izstrādātājiem

UUID v4 struktūra

xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx
|        |    |    |    |
|        |    |    |    └─ 48 bitu nejaušu datu (node)
|        |    |    └────── 16 bitu nejaušu datu ar variantu (clock_seq)
|        |    └─────────── 12 bitu nejaušu datu + 4 biti versijas (time_hi_and_version)
|        └──────────────── 16 bitu nejaušu datu (time_mid)
└───────────────────────── 32 bitu nejaušu datu (time_low)

• Versija (4 biti): vienmēr 0100 (bināri) = 4 (heks)
• Variants (2-3 biti): vienmēr 10 (bināri) RFC 4122

UUID testēšana

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

Drošības aspekti

Ko nedarīt ar UUID

❌ Neizmantojiet UUID v1 sensitīvām lietojumprogrammām – Satur laika zīmogu, kas var radīt drošības risku

❌ Neizmantojiet Math.random() UUID ģenerēšanai – Tas nav kriptogrāfiski drošs

❌ Nepaļaujieties uz UUID autorizācijai – UUID var uzminēt (lai gan ar ārkārtīgi mazu varbūtību)

❌ Neglabājiet UUID sīkfailos bez šifrēšanas – Izmantojiet parakstītus sīkfailus vai JWT

Ko darīt

✅ Lielākajā daļā gadījumu izmantojiet UUID v4 – Visaugstākā entropija un drošība

✅ Apvienojiet UUID ar citiem drošības pasākumiem – Sesiju pārvaldībai izmantojiet HTTPS, HttpOnly sīkfailus un īsu derīguma termiņu

✅ Validējiet UUID serverī – Vienmēr pārbaudiet UUID formātu un versiju

✅ Izmantojiet kriptogrāfiski drošus nejaušības avotus – crypto.getRandomValues() pārlūkprogrammā, /dev/urandom Linuxā

Interesanti fakti

• Iespējamo UUID v4 skaits: 2^122 ≈ 5.3 × 10^36 (340 undeciljoni)
• Nepieciešamā sadursme: Lai iegūtu 50% sadursmes iespējamību, jums jāģenerē 2.71 × 10^18 UUID (2.71 kvintiljoni)
• Visu iespējamo UUID izmērs: Ja mēs katru UUID saglabātu kā 16 baitus, visa telpa aizņemtu 85 zetabaitus (85 miljardus terabaitu)
• Izcelsme: UUID tika standartizēts kā DCE (Distributed Computing Environment) sastāvdaļa 1990. gadā