uToolGo Instrumente Mici, Impact Mare

Instrument de generare UUID

Generează și validează UUID (v1, v4, v5, v7), cu suport pentru generare în loturi și multiple opțiuni de formatare, împreună cu exemple de cod în mai multe limbi.

Generator UUID

Opțiuni de formatare

Validator UUID

Instrucțiuni de utilizare

UUID este un identificator de 128 biți, reprezentat standard ca 36 de caractere cu liniuțe.
UUID v1: bazat pe timestamp și informații despre placa de rețea; ordonat temporal, dar poate expune timpul/locul.
UUID v4: bazat pe numere aleatoare; cel mai utilizat, oferă o bună unicitate și confidențialitate.
UUID v7: bazat pe timp Unix în milisecunde + număr aleator; ordonabil natural, fără probleme de confidențialitate ca v1.
UUID v5: bazat pe un namespace UUID și un nume, calculat prin SHA-1; aceleași intrări produc mereu același rezultat.
Format standard: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx (36 de caractere).

Caracteristici

  • Suport pentru UUID v1, v4, v5, v7
  • Generare în loturi cu număr personalizat
  • Formatare flexibilă: litere mari, fără liniuțe, cu acolade
  • Validator integrat și recunoaștere automată a versiunii
  • Suport complet pentru internaționalizare și teme multiple

Ce este un UUID?

UUID este un identificator de 128 biți, reprezentat standard ca 36 de caractere cu liniuțe.

UUID v1: bazat pe timestamp și informații despre placa de rețea; ordonat temporal, dar poate expune timpul/locul.

UUID v4: bazat pe numere aleatoare; cel mai utilizat, oferă o bună unicitate și confidențialitate.

UUID v7: bazat pe timp Unix în milisecunde + număr aleator; ordonabil natural, fără probleme de confidențialitate ca v1.

UUID v5: bazat pe un namespace UUID și un nume, calculat prin SHA-1; aceleași intrări produc mereu același rezultat.

UUID Exemple rapide

Format standard:
550e8400-e29b-41d4-a716-446655440000
Format cu litere mari:
550E8400-E29B-41D4-A716-446655440000
Fără liniuțe:
550e8400e29b41d4a716446655440000
Cu acolade:
{550e8400-e29b-41d4-a716-446655440000}

UUID Utilizări comune

  • Identificatori unici pentru înregistrări în baze de date sau resurse
  • Trace ID pentru logare și urmărire evenimente
  • Identificatori publici greu de ghicit
  • Identificatori uniformi în interfețe între sisteme diferite

UUID Întrebări frecvente și capcane

  • v1 și confidențialitate: v1 poate expune timpul/locul; pentru confidențialitate, recomandăm v4.
  • Literele mari și mici sunt echivalente: compararea este insensibilă la caz.
  • Liniuțele sunt doar pentru afișare; dacă nu sunt obligatorii, păstrați-le.
  • Formatul cu acolade este acceptat în anumite medii (ex: registry Windows)
  • v5 este determinist (același namespace + nume => același UUID). Potrivit pentru scenarii idempotente; nepotrivit unde este necesară imprevizibilitatea.

Cum se folosește UUID în limbaje de programare

JavaScript
Generare
// UUID v4 (simple)
function uuidv4(){
  return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, c => {
    const r = Math.random()*16|0, v = c === 'x' ? r : (r&0x3|0x8);
    return v.toString(16);
  });
}
const id = uuidv4();
UUID v7 (timp Unix + aleator)
// UUID v7 (Unix ms + randomness)
function uuidv7(){
  const cryptoObj = (globalThis.crypto || globalThis.msCrypto);
  const rb = n => { const a = new Uint8Array(n); cryptoObj?.getRandomValues ? cryptoObj.getRandomValues(a) : a.forEach((_,i)=>a[i]=Math.random()*256|0); return a; };
  const hex = b => Array.from(b).map(x=>x.toString(16).padStart(2,'0')).join('');
  const ts = BigInt(Date.now()).toString(16).padStart(12,'0');
  const ver = rb(2); ver[0] = (ver[0] & 0x0f) | 0x70;    // set version 7
  const vrn = rb(2); vrn[0] = (vrn[0] & 0x3f) | 0x80;    // RFC4122 variant
  const tail = rb(6);
  return `${ts.slice(0,8)}-${ts.slice(8,12)}-${hex(ver)}-${hex(vrn)}-${hex(tail)}`;
}
const id7 = uuidv7();
Validare
const re=/^[0-9a-f]{8}-[0-9a-f]{4}-[1-57][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
re.test(id); // true/false
PHP
Generare
<?php
// v4 using random_bytes
function uuidv4(){
  $data = random_bytes(16);
  $data[6] = chr((ord($data[6]) & 0x0f) | 0x40);
  $data[8] = chr((ord($data[8]) & 0x3f) | 0x80);
  return vsprintf('%s%s-%s-%s-%s-%s%s%s', str_split(bin2hex($data), 4));
}
$id = uuidv4();
UUID v7 (timp Unix + aleator)
<?php
// composer require ramsey/uuid:^4.7
use Ramsey\Uuid\Uuid;

$uuid7 = Uuid::uuid7();
Validare
<?php
$re = '/^[0-9a-f]{8}-[0-9a-f]{4}-[1-57][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i';
preg_match($re, $id) === 1; // true/false
Python
Generare
import uuid
# v4
uid = uuid.uuid4()
# v1
uid1 = uuid.uuid1()
UUID v7 (timp Unix + aleator)
# pip install uuid6
from uuid6 import uuid7

uid7 = uuid7()
Validare
import re
re_uuid = re.compile(r'^[0-9a-f]{8}-[0-9a-f]{4}-[1-57][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$', re.I)
bool(re_uuid.match(str(uid)))
Go
Generare
// go get github.com/google/uuid
import "github.com/google/uuid"

id := uuid.New()     // v4
id1 := uuid.NewUUID() // v1 (may return error)
UUID v7 (timp Unix + aleator)
// go get github.com/gofrs/uuid/v5
import (
  uuid "github.com/gofrs/uuid/v5"
)

id7, err := uuid.NewV7()
Validare
import "github.com/google/uuid"
_, err := uuid.Parse(id.String()) // err == nil means valid
Rust
Generare
// Cargo.toml: uuid = { version = "1", features = ["v4", "v1"] }
use uuid::Uuid;

let v4 = Uuid::new_v4();
// v1 requires a context/ts, often via external crate; shown for completeness
UUID v7 (timp Unix + aleator)
// Cargo.toml: uuid = { version = "1", features = ["v7"] }
use uuid::Uuid;

let v7 = Uuid::now_v7();
Validare
use uuid::Uuid;
let ok = Uuid::parse_str(v4.to_string().as_str()).is_ok();
Java
Generare
import java.util.UUID;

UUID id = UUID.randomUUID(); // v4
UUID v7 (timp Unix + aleator)
// Maven: com.github.f4b6a3:uuid-creator
import com.github.f4b6a3.uuid.UuidCreator;

UUID v7 = UuidCreator.getTimeOrderedEpoch(); // UUIDv7
Validare
import java.util.UUID;

try { UUID.fromString(id.toString()); /* valid */ } catch (IllegalArgumentException ex) { /* invalid */ }
Căutare unelte →