Generatore di UUID
Introduzione
Il Toollect Generatore di UUID è uno strumento browser-based che produce Identificatori Univoci Universali (UUID, anche noti come GUID) in tutte le otto versioni standard — da v1 a v8. Che tu abbia bisogno di identificatori casuali per moduli web, chiavi ordinate temporalmente per record di database, ID deterministici con namespace per sistemi distribuiti o UUID in formato personalizzato per integrazione legacy, questo strumento copre l'intero spettro senza richiedere installazione software o elaborazione lato server.
Gli UUID sono uno degli standard identificativi più adottati nell'ingegneria del software, utilizzati ovunque, dalle chiavi primarie di database e identificatori di risorse API alla tracciabilità distribuita e ai token di sessione. Il Toollect Generatore di UUID consolida tutte le versioni UUID in un'unica interfaccia, permettendoti di scegliere la variante giusta per il tuo caso d'uso e generarla istantaneamente con un solo clic.
Tutta la generazione avviene interamente nel tuo browser utilizzando Web Crypto API. Nessun dato viene trasmesso in rete, nessun cookie viene impostato e nessun identificatore viene registrato. Lo strumento funziona offline dopo il caricamento iniziale della pagina e su tutti i browser e dispositivi moderni.
Casi d'Uso
Versioni UUID diverse servono esigenze architetturali differenti. Scegliere la versione giusta dipende dai requisiti di ordinamento, determinismo, privacy e coordinamento del sistema.
Chiavi Primarie del Database
Gli UUID eliminano la necessità di una sequenza centrale quando si generano chiavi primarie su istanze di database distribuite. UUID v4 è la scelta più semplice, ma UUID v6 e v7 offrono un ordinamento temporale che riduce significativamente la frammentazione degli indici B-tree in database come PostgreSQL e MySQL. Per i sistemi che necessitano sia di univocità globale che di buone prestazioni di scrittura, v7 è diventato la scelta moderna raccomandata.
Identificatori per Sistemi Distribuiti
I microservizi e i sistemi distribuiti spesso generano identificatori in modo indipendente su nodi diversi. UUID v1 include un identificatore di nodo (derivato dall'indirizzo MAC) e una sequenza dell'orologio, rendendo gli ID di ciascun nodo intrinsecamente univoci senza coordinamento. UUID v4 e v7 sono anche popolari per questo scenario grazie alla loro semplicità.
ID Deterministici Basati sul Nome
Quando lo stesso input deve produrre sempre lo stesso UUID — ad esempio, generare un identificatore stabile da un'email utente, un URL di risorsa o un nome qualificato da namespace — UUID v3 (basato su MD5) e v5 (basato su SHA-1) forniscono determinismo. Questo è utile per storage content-addressable, identità di entità nell'event sourcing e migrazione di dati legacy senza cambiare identificatori.
Identificatori di Risorse API
Esporre interi auto-incrementanti nelle URL API rivela informazioni sulla quantità e l'ordine delle risorse. Gli UUID forniscono identificatori opachi che non rivelano nulla sugli interni del sistema. UUID v4 è la scelta più comune per i percorsi delle risorse REST API. Le opzioni di formattazione maiuscolo e senza trattini dello strumento facilitano l'adattamento degli UUID a diverse convenzioni URL e di formattazione.
Sistemi Personalizzati e Legacy
UUID v2 (DCE Security) aggiunge identificatori di utente e gruppo locali per contesti di sicurezza a livello di sistema operativo. UUID v8 consente layout di campo personalizzati per sistemi che devono incorporare bit di dati specifici mantenendo il formato UUID standard. Queste versioni sono di nicchia ma preziose per scenari di integrazione specializzati.
Come Funziona
Il Generatore di UUID opera interamente lato client. Quando selezioni una versione e clicchi su genera, lo strumento invoca l'algoritmo appropriato utilizzando JavaScript e Web Crypto API del browser.
Per gli UUID basati su casualità (v4), lo strumento chiama crypto.getRandomValues() per produrre byte casuali crittograficamente sicuri, poi li formatta nel layout UUID standard con i corretti bit di versione e variante. Per gli UUID basati sul tempo (v1, v2, v6, v7), lo strumento legge il timestamp corrente dall'orologio di sistema e lo combina con byte casuali di sequenza dell'orologio e nodo. Per gli UUID basati sul nome (v3, v5), lo strumento esegue l'hash di un namespace e nome insieme utilizzando MD5 o SHA-1 tramite SubtleCrypto API, quindi estrae 128 bit nel formato UUID standard.
Formato UUID
Un UUID è un valore a 128 bit visualizzato come stringa di 36 caratteri nel formato xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx, dove ogni x è una cifra esadecimale. I 128 bit sono strutturati in campi:
| Campo | Bit | Scopo |
|---|---|---|
time_low |
32 | 32 bit bassi del timestamp (v1, v2, v6) |
time_mid |
16 | 16 bit medi del timestamp |
time_hi_and_version |
16 | 12 bit alti del timestamp + 4 bit di versione |
clock_seq_hi_and_reserved |
8 | 6 bit alti della sequenza orologio + 2 bit di variante |
clock_seq_low |
8 | 8 bit bassi della sequenza orologio |
node |
48 | Identificatore di nodo (indirizzo MAC o casuale) |
Il nibble di versione (bit 48-51, il nibble più significativo del terzo gruppo) identifica quale algoritmo ha prodotto l'UUID: 0001 (v1), 0010 (v2), 0011 (v3), 0100 (v4), 0101 (v5), 0110 (v6), 0111 (v7), 1000 (v8). Questo è il 4 che vedi in un UUID v4 standard come 550e8400-e29b-41d4-a716-446655440000.
I bit di variante (bit 64-65, i due bit più significativi del primo byte del quarto gruppo) indicano la variante UUID. RFC 9562 specifica la variante 10xxxxxx (bit 64-65 = 10), il che significa che il primo carattere del quarto gruppo è sempre 8, 9, a o b.
Esempio di Layout Binario
La struttura a 128 bit di un UUID si comprende meglio visivamente. Prendendo un UUID v4 concreto 550e8400-e29b-41d4-a716-446655440000, ecco come i bit mappano a ciascun gruppo e campo:
Gruppo: 1 2 3 4 5
Hex: 550e8400 e29b 41d4 a716 446655440000
Binario: [32 bit] [16 bit] [16 bit] [16 bit] [48 bit]
Nibble di versione (gruppo 3, nibble alto):
550e8400-e29b-4 1d4-a716-446655440000
^
versione = 0100 (v4)
Bit di variante (gruppo 4, byte alto):
550e8400-e29b-41d4- a 716-446655440000
^
variante = 10xxxxxx
Scomposizione binaria completa dei gruppi 3-4:
gruppo 3 (16 bit) inizio gruppo 4 (8 bit)
0100 0001 1101 0100 1010 0111
└─┘ └─┘
ver=0100 (v4) variante | clock_seq_hi
10
Per UUID v7, i primi 48 bit codificano il timestamp Unix in millisecondi:
018f3a6e-1a2b- 7 bcd-8a1b-2c3d4e5f6789
^
versione = 0111 (v7)
gruppi 1-2: timestamp Unix ms a 48 bit
0000 0001 1000 1111 0011 1010 0110 1110 0001 1010 0010 1011
nibble alto gruppo 3:
0111 = versione 7
Il byte alto del gruppo 4 (a nell'esempio sopra) contiene i bit di variante. Poiché la variante è 10, questo byte cade sempre nell'intervallo 1000 0000 (0x80) fino a 1011 1111 (0xBF), che in hex corrisponde a 8, 9, a o b come primo carattere del quarto gruppo.
Versioni UUID Spiegate
La seguente tabella riassume le otto versioni UUID standard a colpo d'occhio:
| Versione | Algoritmo | Input Principale | Deterministico | Ordinabile | Uso Tipico |
|---|---|---|---|---|---|
| v1 | Basato sul tempo + Nodo | Timestamp, sequenza orologio, MAC | No | Sì (tempo) | Sistemi distribuiti, ID temporali legacy |
| v2 | DCE Security | Timestamp, POSIX UID/GID | No | Sì (tempo) | Identificatori ambiente DCE (nicchia) |
| v3 | Hash MD5 | Namespace + nome | Sì | No | ID basati sul nome dove MD5 è sufficiente |
| v4 | Casuale | 122 bit casuali | No | No | Identificatori generici |
| v5 | Hash SHA-1 | Namespace + nome | Sì | No | Identificatori basati sul nome (raccomandato su v3) |
| v6 | Tempo riordinato | Timestamp (tempo-alto prima) | No | Sì (tempo) | Chiavi database ordinate temporalmente |
| v7 | Timestamp Unix + casuale | Timestamp Unix ms + casuale | No | Sì (ms) | Identificatori moderni ordinati temporalmente |
| v8 | Personalizzato | Campi definiti dall'utente | Dipende | Dipende | Formati personalizzati sperimentali o proprietari |
UUID v1 — Basato sul Tempo
UUID v1 combina un timestamp a 60 bit (intervalli di 100 nanosecondi dal 15 ottobre 1582), una sequenza orologio a 14 bit (per rilevamento di rollback dell'orologio) e un identificatore di nodo a 48 bit (tradizionalmente derivato dall'indirizzo MAC). Questo dà a ciascun nodo generante uno spazio identificativo univoco senza coordinamento.
Il timestamp è disposto con le parti bassa, media e alta attraverso i primi tre gruppi dell'UUID. Questo layout non sequenziale significa che gli UUID v1 sono ordinabili temporalmente ma non in un ordine monotono database-friendly — v6 e v7 risolvono questo problema.
UUID v2 — DCE Security
UUID v2 estende il layout del timestamp e della sequenza orologio di v1 ma sostituisce il campo nodo a 48 bit con un ID utente (UID) o ID gruppo (GID) POSIX a 32 bit e un identificatore di dominio locale a 6 bit. I restanti 10 bit del campo nodo e 2 bit della sequenza orologio vengono riutilizzati per il dominio locale e la sua struttura:
| Campo | Bit | Fonte |
|---|---|---|
| Timestamp | 60 | Stessa epoca di v1 (tick da 100 ns dal 1582-10-15) |
| Sequenza orologio | 6 | Standard, ridotta da 14 bit |
| Dominio locale | 6 | Identifica il dominio UID (POSIX, DCE, ecc.) |
| Identificatore locale | 32 | Valore POSIX UID o GID |
UUID v2 è specificato nello standard DCE 1.1: Remote Procedure Call, non nella specifica UUID principale RFC 9562. È usato raramente al di fuori di ambienti DCE legacy, e la maggior parte dei generatori UUID moderni lo omettono o lo includono solo per completezza. Se stai costruendo un nuovo sistema, usa v4, v7 o v5.
UUID v3 — Basato sul Nome MD5
UUID v3 genera un UUID deterministico da un UUID namespace e una stringa nome. Il processo concatena i byte del namespace e del nome, calcola un hash MD5 e prende i primi 128 bit come UUID. Lo stesso namespace e nome producono sempre lo stesso UUID v3, rendendolo adatto per content addressing e identificatori stabili.
Vedi la sezione UUID v3 vs v5 qui sotto per un confronto delle due versioni basate sul nome.
UUID v4 — Casuale
UUID v4 utilizza 122 bit generati casualmente più 6 bit fissi (4 per il nibble di versione, 2 per la variante). Questa è la versione UUID più utilizzata, supportata direttamente dalla maggior parte delle librerie standard dei linguaggi di programmazione. Il Toollect Generatore di UUID usa crypto.getRandomValues() per garantire casualità crittograficamente sicura, rendendo l'output adatto per contesti sensibili alla sicurezza come i token di sessione.
La probabilità di collisione su un miliardo di UUID v4 generati è di circa 1 su 5,3 × 10²¹ — trascurabile per tutti gli scopi pratici.
UUID v5 — Basato sul Nome SHA-1
UUID v5 è la controparte di v3, utilizzando SHA-1 invece di MD5 per l'hash sottostante. Produce le stesse garanzie di determinismo (stesso namespace + nome = stesso UUID) con un algoritmo di hashing più resistente alle collisioni. Per i nuovi sistemi che necessitano di UUID basati sul nome, RFC 9562 raccomanda v5 su v3.
Vedi la sezione UUID v3 vs v5 qui sotto per il confronto dettagliato.
UUID v6 — Tempo Riordinato
UUID v6 ristruttura il timestamp di v1 per posizionare i bit temporali più significativi per primi. Questo rende gli UUID v6 monotonicamente crescenti quando ordinati lessicograficamente, a differenza di v1 dove il timestamp è suddiviso tra campi non adiacenti. UUID v6 è un sostituto moderno per v1 in ambienti dove gli indici di database ordinati temporalmente o lo storage ordinato sono importanti.
UUID v7 — Timestamp Unix + Casuale
UUID v7 utilizza un timestamp Unix a 48 bit in millisecondi seguito da 74 bit casuali. Il timestamp occupa i bit più significativi, rendendo gli UUID v7 ordinabili per tempo di creazione — ideale per chiavi primarie di database dove le prestazioni degli indici B-tree sono importanti. UUID v7 è più semplice di v1 o v6 perché non richiede indirizzi MAC, sequenze orologio o conversioni di epoca da 100 ns.
Per i nuovi sistemi che necessitano di UUID ordinati temporalmente, v7 è generalmente la scelta migliore: fornisce ordinamento con precisione al millisecondo, ampia casualità e implementazione immediata.
UUID v8 — Personalizzato
UUID v8 riserva lo spazio identificativo della versione 8 per formati UUID sperimentali o proprietari. Gli unici bit fissi sono il nibble di versione a 4 bit (1000) nei bit 48-51 e la variante a 2 bit (10) nei bit 64-65 — i restanti 122 bit sono liberi per qualsiasi layout di campo personalizzato.
| Campo | Bit | Vincolo |
|---|---|---|
| Contenuto personalizzato | 48 | Bit 0-47 (gruppi 1-2), forma libera |
| Versione | 4 | Fisso a 1000 |
| Contenuto personalizzato | 12 | Bit 52-63 (fine gruppo 3), forma libera |
| Variante | 2 | Fisso a 10 |
| Contenuto personalizzato | 62 | Bit 66-127 (gruppi 4-5), forma libera |
Gli usi comuni di UUID v8 includono l'incorporamento di un prefisso aziendale specifico, la combinazione di un timestamp troncato con un contatore di sequenza o la codifica di un identificatore legacy in formato UUID mantenendo la compatibilità con il formato standard. Ad esempio, un sistema potrebbe allocare i primi 32 bit come ID tenant, i successivi 32 bit come timestamp in millisecondi e i restanti 64 bit come suffisso casuale — tutto in un formato che qualsiasi parser UUID standard può leggere senza modifiche.
Il formato v8 non è registrato presso IANA e non ha garanzie di interoperabilità tra sistemi. È uno spazio privato per casi in cui le versioni UUID standard non si adattano al layout dati richiesto.
UUID v3 vs v5
Sia UUID v3 che v5 generano identificatori deterministici da un UUID namespace e un nome, ma differiscono nel loro algoritmo di hashing:
| Aspetto | UUID v3 | UUID v5 |
|---|---|---|
| Algoritmo hash | MD5 (128 bit) | SHA-1 (160 bit, troncato a 128) |
| Resistenza collisioni | Inferiore — MD5 è considerato crittograficamente compromesso | Superiore — nessun attacco di collisione pratico |
| Prestazioni | Leggermente più veloce (MD5 vs SHA-1) | Leggermente più lento |
| Raccomandazione standard | Solo per retrocompatibilità v3 | RFC 9562 raccomanda v5 per nuovi sistemi |
| Interoperabilità | Richiesta se il sistema esistente usa v3 | Richiesta se il sistema esistente usa v5 |
Il Toollect Generatore di UUID include quattro namespace standard predefiniti definiti da RFC 9562: DNS (6ba7b810-9dad-11d1-80b4-00c04fd430c8), URL (6ba7b811-9dad-11d1-80b4-00c04fd430c8), OID (6ba7b812-9dad-11d1-80b4-00c04fd430c8) e X.500 (6ba7b814-9dad-11d1-80b4-00c04fd430c8). Puoi anche fornire un namespace personalizzato in formato UUID standard per l'uso con namespace non standard.
Utilizzo
Usare il Toollect Generatore di UUID non richiede configurazione o registrazione. L'interfaccia è divisa in due pannelli — uno per UUID v1/v2/v4/v6/v7/v8 (generazione istantanea) e uno per UUID v3/v5 (generazione basata sul nome).
Blocco 1 — UUID Standard (v1, v2, v4, v6, v7, v8)
- Seleziona la versione UUID dal menu a tendina. Il default è v4.
- Clicca su Genera o premi Invio. Un nuovo UUID appare immediatamente nel campo di output.
- Attiva/disattiva le opzioni di formattazione secondo necessità:
- Maiuscolo: Converte l'output in cifre esadecimali maiuscole.
- Senza Trattini: Rimove i trattini, producendo una stringa compatta di 32 caratteri.
- Copia il risultato cliccando sul pulsante Copia accanto al campo di output.
Il cambio del menu a tendina della versione attiva la rigenerazione automatica, quindi passare da v4 a v7 produce immediatamente un nuovo identificatore.
Blocco 2 — UUID Basati sul Nome (v3, v5)
- Seleziona v3 o v5 dal menu a tendina della versione nel pannello basato sul nome.
- Scegli un namespace selezionando una delle opzioni predefinite (DNS, URL, OID, X.500) o Personalizzato.
- Se usi un namespace personalizzato, inserisci un UUID valido nel campo di testo. Lo strumento convalida il formato e mostra un errore se l'UUID è malformato.
- Inserisci il nome nel campo di input del nome. L'UUID viene rigenerato automaticamente mentre digiti.
- Attiva/disattiva formattazione maiuscolo e senza trattini e Copia il risultato come nel Blocco 1.
Il pannello basato sul nome genera UUID a ogni modifica dell'input — non c'è un pulsante di generazione separato per questo pannello.
Tutorial
Questo tutorial illustra tre scenari comuni dall'apertura dello strumento alla copia dell'UUID finale.
Scenario 1: Generare un UUID v4 per un Modulo Web
- Apri lo strumento nel tuo browser. L'interfaccia del Generatore di UUID mostra due pannelli.
- Nel Blocco 1, assicurati che il menu a tendina della versione sia impostato su v4 (il default).
- Clicca su Genera. Appare un UUID v4, ad esempio
550e8400-e29b-41d4-a716-446655440000. - Clicca su Copia per copiare l'UUID negli appunti, poi incollalo nel tuo modulo web o richiesta API.
- Attiva Maiuscolo e clicca su Genera di nuovo per produrre
550E8400-E29B-41D4-A716-446655440000. - Attiva Senza Trattini per produrre
550e8400e29b41d4a716446655440000per storage compatto o parametri URL.
Scenario 2: Generare un UUID v7 Ordinato Temporalmente per una Chiave Primaria del Database
Supponi di stare progettando una tabella in PostgreSQL che necessita di chiavi primarie globalmente univoche senza una sequenza centrale, ma vuoi anche buone prestazioni di scrittura.
- Seleziona v7 dal menu a tendina della versione del Blocco 1. Il campo di output mostra immediatamente un nuovo UUID v7, come
018f3a6e-1a2b-7bcd-8a1b-2c3d4e5f6789. - Nota i primi caratteri — UUID v7 inizia con un timestamp Unix in millisecondi, quindi generazioni successive mostreranno valori crescenti nei primi gruppi.
- Genera diversi UUID in rapida successione e osserva che i valori sono monotoni: ogni nuovo UUID inizia con un prefisso maggiore o uguale al precedente.
- Copia l'identificatore per usarlo nella tua istruzione
INSERT:INSERT INTO users (id, name) VALUES ('018f3a6e-1a2b-7bcd-8a1b-2c3d4e5f6789', 'Alice');
Scenario 3: Generare un UUID v5 Deterministico da un URL di Risorsa
Immagina di avere un sistema di gestione dei contenuti dove ogni articolo è identificato dal suo URL e hai bisogno di un UUID stabile che non cambi tra distribuzioni.
- Nel Blocco 2, imposta la versione su v5.
- Seleziona il namespace URL dai pulsanti radio del namespace. Questo usa
6ba7b811-9dad-11d1-80b4-00c04fd430c8, il namespace standard per UUID basati su URL. - Inserisci l'URL dell'articolo nel campo Nome, ad esempio
https://example.com/articles/uuid-guide. - L'UUID appare automaticamente — ogni volta che inserisci lo stesso URL con il namespace URL, ottieni lo stesso UUID.
- Testa il determinismo: Seleziona invece il namespace DNS e osserva che l'UUID cambia. Torna su URL — l'UUID originale riappare.
Suggerimenti Avanzati
Padroneggia queste tecniche avanzate per ottenere il massimo dal Toollect Generatore di UUID:
-
Usa v7 invece di v1 per le chiavi primarie del database: UUID v7 ordina per timestamp in millisecondi dai bit più significativi, offrendo un ordinamento monotono B-tree-friendly senza la complessità degli indirizzi MAC o della gestione della sequenza orologio. Per nuovi progetti che richiedono UUID ordinati temporalmente, inizia con v7.
-
Preferisci v5 a v3 per UUID basati sul nome: A meno che tu non debba interoperare con un sistema che usa v3, usa sempre UUID v5. SHA-1 offre un margine di collisione maggiore di MD5 con una differenza di prestazioni trascurabile. Lo strumento imposta v5 come default nel pannello basato sul nome per questo motivo.
-
Rimuovi i trattini per i parametri URL: Attiva Senza Trattini quando usi UUID in percorsi URL o parametri di query. Senza trattini, un UUID diventa una stringa esadecimale di 32 caratteri che non richiede codifica URL ed è visivamente più pulita nei segmenti di route.
-
Usa namespace predefiniti per identificatori coerenti tra sistemi: I namespace DNS, URL, OID e X.500 sono standardizzati in RFC 9562. Usarli garantisce che qualsiasi generatore UUID conforme a RFC produca lo stesso UUID v3 o v5 per lo stesso nome. Questo è essenziale per l'accordo tra sistemi.
-
Namespace personalizzato con un UUID v4 fisso: Quando crei il tuo namespace per UUID v3/v5, genera un UUID v4 una volta, salvalo nella tua configurazione e riutilizzalo. Questo garantisce che tutti gli identificatori nel tuo namespace personalizzato siano distinti da qualsiasi altro namespace.
-
Genera in batch cliccando più volte: Per piccoli lotti, cliccare rapidamente su Genera produce UUID distinti ogni volta. Per generazione su larga scala, usa il metodo da riga di comando o programmatico descritto sotto.
Idee Sbagliate Comuni sugli UUID
Diverse credenze ampiamente ripetute sugli UUID sono inaccurate o fuorvianti. Comprendere le sfumature ti aiuta a prendere decisioni architetturali migliori.
"Gli UUID sono garantiti univoci al 100%." Nessun sistema di identificazione fornisce garanzie assolute, ma gli UUID offrono una resistenza alle collisioni astronomicamente alta se usati correttamente. Per UUID v4, la probabilità di almeno una collisione su un miliardo di ID generati è approssimativamente 1 su 10¹⁴. Per le versioni basate sul tempo (v1, v6, v7), le collisioni tra nodi diversi richiedono un reset simultaneo dell'orologio su più macchine. Il tasso di collisione pratico su tutti gli UUID implementati correttamente è effettivamente zero.
"UUID v4 è sempre la scelta migliore." UUID v4 è il più generico e va bene per la maggior parte delle applicazioni, ma non è ottimale per tutti gli scenari. Per le chiavi primarie del database, la distribuzione casuale di v4 causa suddivisioni delle pagine degli indici e amplificazione di scrittura negli indici B-tree. UUID v7 offre un ordinamento temporale che mantiene gli indici più efficientemente. Per identificatori deterministici che devono essere riproducibili da un nome, v3 o v5 è l'unica scelta corretta.
"Gli UUID sono completamente casuali." Solo UUID v4 è completamente casuale (122 bit di entropia). UUID v1, v2, v6 e v7 incorporano timestamp, rendendoli parzialmente prevedibili — informazioni che potrebbero essere divulgate attraverso l'identificatore. UUID v3 e v5 sono deterministici per un dato input. Se l'imprevedibilità è un requisito (token di sicurezza, identificatori di sessione), usa v4 con Web Crypto API.
"Tutti gli UUID hanno lo stesso formato." Tutti gli UUID RFC 9562 condividono il formato esadecimale a 36 caratteri 8-4-4-4-12, ma la struttura interna differisce radicalmente tra le versioni. Un UUID v1 incorpora bit di indirizzo MAC e timestamp; UUID v4 è pura casualità; UUID v7 combina un timestamp con bit casuali. Puoi identificare la versione dal 13° carattere (4 = v4, 7 = v7, ecc.) e la variante dal 17° carattere (8, 9, a o b).
"Gli UUID rallentano le prestazioni del database." Questo era parzialmente vero con versioni più vecchie del database e UUID v4 memorizzati come stringhe ASCII. I database moderni (PostgreSQL con tipo uuid, MySQL 8+ con UUID_TO_BIN, SQL Server) memorizzano gli UUID come valori binari a 16 byte con supporto nativo per indici. UUID v7 mitiga ulteriormente la frammentazione degli indici attraverso la generazione ordinata temporalmente. La differenza di prestazioni rispetto agli interi auto-incrementanti è trascurabile per la maggior parte dei carichi di lavoro.
Alternative
Esistono diverse alternative al Toollect Generatore di UUID, ciascuna adatta a flussi di lavoro differenti.
| Strumento / Metodo | Ideale Per | Limitazioni |
|---|---|---|
| Toollect Generatore di UUID | Generazione browser-based, tutte le versioni v1-v8, nessuna installazione, privacy-first | Richiede internet per il caricamento iniziale della pagina, non scriptabile |
Comando Unix uuidgen |
Generazione batch da terminale, scripting, integrazione pipeline | Tipicamente solo v1 e v4; varia in base all'implementazione della piattaforma |
| ULID | ID ordinabili base32 a 26 caratteri, URL-safe, case-insensitive | Nessun bit di versione/variante; non compatibile UUID; limitato a 80 bit di casualità |
| NanoID | ID URL-safe brevi (default 21 caratteri), alfabeto e lunghezza configurabili | Non è un UUID; nessuna formattazione o versionamento standard; lunghezza variabile in base alla configurazione |
| Snowflake (stile Twitter) | ID ordinati temporalmente a 64 bit, molto compatti, alto throughput in sistemi distribuiti | Richiede coordinamento ID worker; non formato UUID; implementazioni specifiche della piattaforma |
| Generatori UUID online (es. uuidgenerator.net) | Generazione rapida singola UUID offline | Limitati a una o due versioni; spesso nessuna casualità crittografica; possono inviare dati al server |
PostgreSQL gen_random_uuid() |
Generazione lato database al momento INSERT | Solo PostgreSQL; tipicamente solo v4; niente v7 o versioni basate sul nome senza estensioni |
Modulo Python uuid |
Generazione programmatica in applicazioni Python | Richiede runtime Python; non browser-based |
Node.js crypto.randomUUID() |
Generazione lato server Node.js | Solo Node.js; manca versioni basate sul tempo e sul nome |
Web Crypto API (crypto.randomUUID) |
Generazione nativa v4 nel browser con zero dipendenze | Supporta solo v4; nessuna opzione di formattazione o UUID basati sul nome |
Per la maggior parte degli utenti che desiderano generazione UUID istantanea, privata e multiversione senza lasciare il browser, il Toollect Generatore di UUID offre il set di funzionalità più completo.
Privacy dei Dati
Il Toollect Generatore di UUID elabora ogni byte dei tuoi dati interamente nel tuo browser. Nessun dato inserito — nomi, namespace o identificatori generati — viene trasmesso a server, memorizzato in database o registrato in alcun sistema.
Tutta la generazione utilizza Web Crypto API integrata di JavaScript (crypto.getRandomValues, crypto.randomUUID, crypto.subtle.digest). La pagina dello strumento non include script di analytics, pixel di tracciamento, cookie o embed di terze parti. Nessuna voce localStorage o sessionStorage viene creata o letta.
Dopo il caricamento iniziale della pagina, il Generatore di UUID funziona completamente offline — genera identificatori anche in modalità aereo con zero attività di rete. Puoi verificarlo ispezionando la scheda Rete negli strumenti di sviluppo del tuo browser o disconnettendoti completamente da internet.
Risoluzione dei Problemi
| Problema | Causa Probabile | Soluzione |
|---|---|---|
| L'output UUID v4 si ripete tra generazioni | crypto.getRandomValues() potrebbe essere simulato o non disponibile in ambienti di test |
Nei browser di produzione, crypto.getRandomValues() restituisce sempre entropia fresca. Testa generando dieci UUID in sequenza — dovrebbero essere tutti diversi. |
| UUID basato sul nome (v3/v5) non mostra output | Il campo Nome è vuoto o il namespace personalizzato non è valido | Assicurati che il campo Nome contenga testo. Se usi un namespace personalizzato, verifica che sia un UUID valido in formato standard (xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx). |
| La convalida del namespace personalizzato fallisce | Il formato UUID non è corretto — trattini mancanti, lunghezza errata o caratteri hex non validi | Inserisci il namespace come UUID completo di 36 caratteri inclusi i trattini. Lo strumento convalida il formato prima di generare. |
| Il pulsante Copia non funziona | L'API degli appunti del browser richiede contesto sicuro o gesto dell'utente | Assicurati che la pagina sia servita su HTTPS. Il pulsante Copia usa navigator.clipboard.writeText(), che funziona in tutti i browser moderni su pagine HTTPS. |
| UUID v1 mostra valori inaspettati | Il timestamp o la sequenza orologio potrebbero essere stati avvolti | UUID v1 usa tick da 100 ns dall'ottobre 1582. Il ciclo dell'orologio nel 2026 è ben all'interno dell'intervallo a 60 bit (~292 anni). Le sequenze orologio si resettano naturalmente se l'orologio di sistema torna indietro. |
Il browser non supporta crypto.randomUUID |
Versione del browser obsoleta | Lo strumento ricade internamente su crypto.getRandomValues(). Supportato in Chrome 80+, Firefox 75+, Safari 13+, Edge 80+. |
| I valori UUID v7 non sono strettamente crescenti | Due generazioni nello stesso millisecondo producono lo stesso prefisso timestamp | UUID v7 usa precisione al millisecondo. Entro lo stesso millisecondo, generazioni multiple condividono lo stesso timestamp; il suffisso casuale cambia ogni volta. Questo è voluto e non influisce sull'ordinamento degli indici del database. |
Specifiche Tecniche
Il Toollect Generatore di UUID è progettato per correttezza, prestazioni e compatibilità cross-browser.
Conformità agli Standard
| Aspetto | Specifica |
|---|---|
| RFC | RFC 9562 (sostituisce RFC 4122) |
| Formato UUID | 128 bit, xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx |
| Variante | Variante RFC 9562 (10xxxxxx) |
| Maiuscole/minuscole | Minuscolo di default, attivabile maiuscolo |
| Trattini | Inclusi di default, rimovibili con opzione senza trattini |
Dettagli Algoritmo per Versione
| Versione | Fonte di Entropia | Tempo di Generazione |
|---|---|---|
| v1 | performance.now() per timestamp, crypto.getRandomValues() per sequenza orologio e nodo |
< 1 ms |
| v2 | Stesso di v1 con POSIX UID/GID (locale), campo nodo adattato | < 1 ms |
| v3 | MD5 tramite crypto.subtle.digest() |
~2-5 ms (async) |
| v4 | crypto.getRandomValues() |
< 1 ms |
| v5 | SHA-1 tramite crypto.subtle.digest() |
~2-5 ms (async) |
| v6 | Stesso timestamp di v1 ma riordinato (tempo-alto prima) | < 1 ms |
| v7 | Date.now() per timestamp, crypto.getRandomValues() per suffisso casuale |
< 1 ms |
| v8 | crypto.getRandomValues() per bit casuali |
< 1 ms |
Compatibilità Browser
| Browser | Versione Minima | Stato |
|---|---|---|
| Google Chrome | 80+ | Supporto completo |
| Mozilla Firefox | 75+ | Supporto completo |
| Apple Safari | 13+ | Supporto completo |
| Microsoft Edge | 80+ | Supporto completo |
| Samsung Internet | 13+ | Supporto completo |
| Opera | 67+ | Supporto completo |
Privacy e Sicurezza
- Zero trasmissione dati: tutta la generazione avviene nella memoria del browser
- Nessun cookie, localStorage o sessionStorage utilizzato
- Nessuno script di analytics o tracciamento sulla pagina dello strumento
- Completamente funzionante in modalità offline dopo il caricamento iniziale della pagina
- Nessuna registrazione, login o chiavi API richieste
- Casuale crittograficamente sicura tramite Web Crypto API
Caratteristiche
- Genera tutte le versioni UUID da v1 a v8, incluse quelle basate sul tempo (v1, v6, v7), casuali (v4), basate sul nome (v3, v5), DCE security (v2) e personalizzate (v8)
- Generazione casuale crittograficamente sicura tramite Web Crypto API con zero trasmissione in rete
- Attiva/disattiva output maiuscolo e rimuovi trattini per UUID compatti o pronti per la visualizzazione
- Generazione UUID basata sul nome con namespace integrati (DNS, URL, OID, X.500) e supporto namespace personalizzato con convalida
- Elaborazione 100% lato client — nessun dato caricato su server, nessuna registrazione o installazione richiesta
- Generazione e copia con un clic con risultati istantanei su tutti i browser e dispositivi moderni