Generatore UUID
Opzioni di formato
Numero generato
Generatore UUID/GUID/ULID/NanoID online gratuito che supporta 5 formati di ID univoci, generazione in massa fino a 100, formattazione personalizzabile e convalida UUID. Pronto all'uso istantaneo: perfetto per chiavi primarie di database e creazione di dati di test.
Raccomandazioni correlate
Cos'è un UUID?
UUID (Universally Unique Identifier) è uno standard di identificatore a 128 bit standardizzato dalla Open Software Foundation (OSF), definito in RFC 4122. Il suo scopo è consentire ai sistemi distribuiti di identificare in modo univoco le informazioni senza un'autorità centrale per l'assegnazione degli ID.
Un UUID standard appare come `550e8400-e29b-41d4-a716-446655440000`, composto da 32 cifre esadecimali divise in 5 gruppi (8-4-4-4-12) da trattini. Teoricamente, la probabilità di collisione di UUID v4 è di circa 1/10^36: se generassi 1 miliardo di UUID al secondo per circa 800 anni, la probabilità di una singola collisione sarebbe di circa il 50%, il che è trascurabile nella pratica.
Gli UUID sono ampiamente utilizzati per chiavi primarie di database, ID di tracciamento distribuito, ID di richiesta, ID di tracciamento dei log, denominazione univoca di file, ID di dati di test e identificatori di sessione. Quasi tutti i linguaggi di programmazione principali includono librerie di generazione UUID integrate.
Casi d'uso
- Genera UUID v4 come chiavi primarie di record di tabella durante la progettazione del database per evitare la divulgazione del volume di dati da ID autoincrementali
- Usa ULID come ID di richiesta/tracciamento globali ordinabili in sistemi distribuiti o architetture di microservizi
- Genera UUID in massa come dati di test e ID di ordine/utente simulati durante lo sviluppo di API e i test di integrazione
- Usa NanoID invece di UUID in collegamenti brevi front-end o URL di condivisione: più corti, più puliti, nessuna codifica URL necessaria
- Usa UUID v5 per generare ID deterministici da namespace fissi, garantendo che lo stesso input produca sempre lo stesso output
- Usa la funzione di convalida per identificare tipo e versione di ID quando incontri ID di formato sconosciuto nei log di debug o nella documentazione di terze parti
Come utilizzare
- Seleziona il tipo di ID desiderato dalle schede sopra: UUID v4 (consigliato), v1, v5, ULID o NanoID
- Se scegli UUID v5, inserisci una stringa di namespace; per altri ID puoi impostare direttamente le opzioni di formato
- Alterna le opzioni maiuscole e trattini secondo necessità, imposta il numero di generazione in massa (1-100) tramite pulsanti rapidi o cursore
- Fai clic sul pulsante genera per visualizzare i risultati: copia individualmente, copia tutto in una volta o esporta come TXT/JSON
- Per convalidare un ID esistente, passa alla scheda "Convalida" e incolla la stringa dell'ID per ottenere informazioni su tipo e versione
Funzionalità
- Cinque tipi di ID in un unico strumento: UUID v1 (timestamp), v4 (casuale), v5 (namespace), ULID (ordinabile) e NanoID (sicuro per URL): uno strumento copre tutte le esigenze dello stack tecnologico
- Convalida e riconoscimento UUID: Passa alla scheda Convalida, incolla qualsiasi ID per identificare la sua versione UUID o rilevare il formato ULID/NanoID: risoluzione rapida dei problemi durante il debug
- Genera in massa fino a 100: Genera qualsiasi quantità da 1 a 100 ID in una volta: non devi più copiare manualmente uno per uno per i dati di test
- Formattazione flessibile: Alterna maiuscole e trattini per gli UUID per soddisfare i requisiti di formato di database, URL e file di configurazione
- Esportazione e cronologia locale: Copia tutto con un clic, esporta file TXT/JSON, cronologia di generazione salvata localmente per il recupero istantaneo: operazioni in massa più efficienti
- Casuale sicuro lato client: Utilizza l'API crypto del browser per numeri casuali crittograficamente sicuri, gli ID non lasciano mai il tuo dispositivo, funziona offline
Esempi di codice
Genera UUID v4 in JavaScript
javascriptI browser moderni e Node.js 14.17+ hanno l'API Web Crypto integrata, consentendo la generazione diretta di UUID v4 senza librerie di terze parti.
// Browser moderni / Node.js 19+
const id = crypto.randomUUID();
console.log(id); // "550e8400-e29b-41d4-a716-446655440000"
// Node.js 14.17 - 18.x
const crypto = require('crypto');
const id = crypto.randomUUID();Genera UUID in massa in Python
pythonUsa il modulo uuid della libreria standard di Python per generare più UUID v4 in massa, ideale per la preparazione di dati di test.
import uuid
# Genera un singolo UUID
uid = uuid.uuid4()
print(uid)
# Genera 10 UUID in massa
for _ in range(10):
print(uuid.uuid4())
# Genera UUID in maiuscolo senza trattini
print(uuid.uuid4().hex.upper())Genera UUID dalla riga di comando Shell
bashGenera rapidamente UUID nel terminale Linux/macOS, adatto per l'uso negli script shell.
# Linux uuidgen # macOS uuidgen | tr 'A-Z' 'a-z' # Lettura diretta dal file casuale di sistema (metodo più grezzo) cat /proc/sys/kernel/random/uuid
Quale schema di ID univoco dovresti scegliere?
L'UUID non è l'unica opzione: gli ID auto-incrementali del database e Snowflake sono anche schemi di chiave primaria diffusi. Decidi prima in base a 'volume di dati, necessità di unicità globale e necessità di ordinamento temporale' per evitare molti giri a vuoto.
UUID v1 / v4 / v5 / ULID / NanoID: quale scegliere?
I 5 ID presentano compromessi in volume di dati, ordinabilità e lunghezza dei caratteri. Decidi in base a 'dove viene usato + se serve ordinamento + se viene usato direttamente in URL', più affidabile che basarsi sui numeri stessi.
| Schema | Scenario consigliato | Ordinabilità | Lunghezza | Consiglio |
|---|---|---|---|---|
UUID v1 | Sistemi interni che richiedono ordinamento temporale e possono accettare la fuga di MAC e dell'ora di generazione | Ordinamento temporale | 36 caratteri | ⚠ Generalmente sconsigliato (fuga di privacy) |
UUID v4 | Chiavi primarie di DB, identificatori generici, la maggior parte degli scenari di business | Non ordinato (casuale) | 36 caratteri | ✓ Prima scelta universale |
UUID v5 | Scenari che richiedono output deterministico (stesso input → stesso UUID) | Non ordinato | 36 caratteri | ✓ Consigliato con namespace fisso |
ULID | Chiavi primarie di sistemi distribuiti, tracciamento log, indici con necessità di ordinamento temporale | Ordinamento temporale (i primi 48 bit sono timestamp in millisecondi) | 26 caratteri | ✓ Prima scelta per sistemi distribuiti |
NanoID | Short link URL, identificatori di cookie, riferimenti JS nel frontend | Non ordinato (casuale) | 21 caratteri (predefinito) | ✓ Prima scelta per scenari con ID corti |
UUID vs ID auto-incrementale DB vs Snowflake ID: come scegliere la chiave primaria?
Questi tre sono gli schemi di chiave primaria backend più comuni e determinano scalabilità, sicurezza di concorrenza e prestazioni del sistema. Decidere in base a 'volume di dati / requisito di unicità globale / leggibilità' evita rifacimenti architetturali successivi.
| Dimensione | UUID | ID auto-incrementale DB | Snowflake |
|---|---|---|---|
Unicità globale | ✓ Sì (in teoria) | ✗ No (duplicati dopo sharding del DB) | ✓ Sì (garantita da data center + worker ID) |
Fuga di volume | ✓ Nessuna fuga | ✗ Diretta (1, 2, 3 incrementale rivela il volume reale) | ⚠ I bit di tempo rivelano l'ora di generazione (non il volume totale diretto) |
Ordinabilità | ✗ Non ordinato (ULID è l'eccezione) | ✓ Monotonicamente crescente (amichevole per B-Tree) | ✓ Crescente per tendenza (ordinato nello stesso millisecondo) |
Supporto sharding | ✓ Supporto nativo | ✗ Richiede generatore di ID o refactoring | ✓ Distinguibile tramite worker ID |
Costo di archiviazione | ⚠ Alto (BINARY(16) sono 16 byte) | ✓ Basso (BIGINT sono 8 byte) | ✓ Basso (BIGINT sono 8 byte) |
Scenari adatti | Chiavi primarie multi-servizio/distribuite, identificatori esterni, business sensibili al volume di dati | App monolitiche, backend amministrativi, senza bisogno di unicità globale | IM ad alta concorrenza, numeri d'ordine, ID di messaggi (richiede implementazione propria) |
Best Practices
Per le chiavi primarie in produzione, preferisci UUID v4 o ULID, evita v1
Gli ultimi 48 bit di UUID v1 sono l'indirizzo MAC e i primi 48 bit sono un timestamp con precisione di 100 ns – **questi due campi possono essere invertiti in un'impronta della macchina e nell'ora di generazione**. RFC 4122 chiarisce che v1 dovrebbe essere usato 'solo quando serve la retrocompatibilità'. In produzione, preferisci v4 (casuale) o ULID (ordinabile); usa v1 solo occasionalmente in fase di debug o per risalire alla macchina generatrice. **Non usare mai** v1 come ID utente, ID dispositivo o numero d'ordine esposto all'esterno.
Come scegliere tra UUID v1, v4 e v5?UUID è lungo 128 bit ≠ entropia: v4 ha solo 122 bit di vera casualità
Anche se UUID v4 ha 128 bit in totale, **i primi 4 bit sono il numero di versione (fisso a 0100) e gli ultimi 2 bit sono la variante (fissa a 10)** – solo 122 bit sono davvero casuali. Questa è una limitazione di formato imposta da RFC 4122 – **qualsiasi libreria UUID v4 che dichiari '128 bit completamente casuali' è implementata male**. Inoltre, negli ultimi 64 bit di v4, i 2 bit alti del 7° byte sono anch'essi campi di variante, quindi l'entropia reale è ancora più bassa. Quando progetti un sistema, calcola la sicurezza basandoti su 122 bit (non 128) per non sottostimare il rischio di collisione.
RFC 4122 - Specifica UUIDMemorizza gli UUID come colonne BINARY(16), non VARCHAR(36)
La stringa UUID v4 `550e8400-e29b-41d4-a716-446655440000` può sembrare compatta, ma VARCHAR(36) in realtà occupa 36 byte + 2 byte di lunghezza = 38 byte, **2,4 volte più spazio di BINARY(16)**. MySQL/PostgreSQL/MSSQL hanno funzioni UUID integrate che supportano la scrittura diretta in BINARY(16), e anche la dimensione dell'indice si dimezza. Quando le tabelle superano i 100 milioni di righe, gli indici di chiave primaria VARCHAR(36) fanno crescere l'altezza del B-Tree di 1-2 livelli, **peggiorando le prestazioni delle query del 30-50 %**. Converti in stringa solo per la visualizzazione nel frontend; a livello di business trasporta sempre in BINARY(16).
Tabella comparativa UUID / ULID / NanoIDNegli scenari URL, usa NanoID o UUID senza trattini per evitare la codifica URL
Il set di caratteri di UUID v4 è `[0-9a-f-]`, **e il trattino - nei path URL richiede una doppia codifica URL** (prima in %2D, poi in %252D), il che è poco elegante. Due soluzioni: **(1) per scenari URL, usa direttamente NanoID** (21 caratteri URL-safe di default); **(2) UUID v4 con trattini disabilitati** produce 32 caratteri esadecimali puri, che non richiedono codifica come segmento di path URL. Anche per gli scenari con cookie, preferisci NanoID (A-Za-z0-9_-) o UUID senza trattini, evitando i caratteri `+` `/` `=` (set di caratteri Base64).
Si possono togliere i trattini o convertire gli UUID in maiuscolo?Dopo la generazione in massa, deduplica sempre: bug del generatore possono causare duplicati
La probabilità di collisione di UUID v4 è circa 1/10^36, quindi in teoria non serve deduplicare – **ma in ingegneria, non fidarti della teoria**. Incidenti reali come guasti dell'RNG del kernel Linux, bug nell'implementazione di `crypto.randomUUID` nelle prime versioni di Node.js ed entropia insufficiente all'avvio di VM cloud hanno causato duplicati in UUID generati in massa. **In produzione, dopo aver generato più di 100k UUID in massa, devi eseguire `SELECT id, COUNT(*) FROM t GROUP BY id HAVING COUNT(*) > 1` per deduplicare e verificare** – in caso di problemi, ripristina immediatamente la versione precedente del generatore. È una best practice imparata a proprie spese in scenari di migrazione dati e import in massa.
È possibile generare più UUID in una volta?Domande frequenti
Qual è la differenza tra UUID e GUID?
UUID (Universally Unique Identifier) e GUID (Globally Unique Identifier) sono essenzialmente la stessa cosa con nomi diversi: UUID è il nome formale dello standard IETF (RFC 4122), mentre GUID è il termine preferito da Microsoft nell'ecosistema Windows. Entrambi condividono lo stesso formato a 128 bit come `550e8400-e29b-41d4-a716-446655440000`. Gli UUID standard generati da questo strumento funzionano in modo intercambiabile in qualsiasi scenario che richieda GUID.
Come scegliere tra UUID v1, v4 e v5?
UUID v1 si basa su timestamp e indirizzo MAC: ordinato temporalmente e tracciabile, ma può divulgare informazioni sull'indirizzo MAC. UUID v4 è completamente casuale, la scelta più comune e sicura, adatta alla maggior parte degli scenari di chiavi primarie e identificatori. UUID v5 è una versione basata su hash SHA-1 con namespace: lo stesso namespace + lo stesso nome produce sempre lo stesso UUID, ideale per scenari di output deterministico. Per lo sviluppo generale, UUID v4 è la scelta predefinita.
Quali vantaggi hanno ULID e NanoID rispetto a UUID v4?
ULID (26 caratteri) è più corto di UUID (36 caratteri con trattini) e ordinabile lessicograficamente per tempo di creazione, rendendolo ideale per indici di database e tracciamento dei log. NanoID (21 caratteri predefiniti) è ancora più corto e veloce, utilizza caratteri sicuri per gli URL quindi non è necessario l'escape negli URL e nei cookie: è circa il 30% più piccolo di UUID. Tutti e tre hanno una probabilità di collisione trascurabile, ma l'ordinabilità di ULID brilla nei sistemi distribuiti, mentre NanoID è più conveniente per scenari front-end/URL.
Posso generare più UUID contemporaneamente?
Sì. Questo strumento supporta la generazione in massa da 1 a 100 ID. Imposta il numero tramite pulsanti rapidi o il cursore, quindi genera con un clic: perfetto per la creazione di dati di test, importazioni in massa e preparazione di ID univoci per gli script. Dopo la generazione, puoi copiare tutti i risultati in una volta o esportarli come file TXT o JSON.
Guida alla generazione in massaPosso convalidare se una stringa è un UUID valido?
Sì. Passa alla scheda "Convalida" e incolla qualsiasi stringa: lo strumento identifica e convalida automaticamente: gli UUID standard (v1/v3/v4/v5) riporteranno il loro numero di versione specifico e riconosce anche i formati ULID (26 caratteri Crockford Base32) e NanoID (21 caratteri sicuri per URL), rendendolo molto conveniente per risolvere rapidamente problemi di formato ID durante lo sviluppo e il debug.
Generare UUID online è sicuro? I miei ID verranno divulgati a un server?
Completamente sicuro. Tutta la generazione e la convalida degli ID avviene localmente nel tuo browser tramite JavaScript, utilizzando crypto.getRandomValues() per numeri casuali crittograficamente sicuri. Nessun ID generato viene inviato a nessun server e nessuna cronologia di generazione viene archiviata nel cloud. Funziona anche offline, rendendolo adatto a intranet aziendali e progetti sensibili.
Posso rimuovere i trattini o convertire gli UUID in maiuscolo?
Sì. Per UUID v1/v4/v5, lo strumento fornisce due interruttori: "Maiuscolo" cambia la capitalizzazione dell'output e "Trattini" ti consente di rimuovere i trattini (utile per URL, file di configurazione o database che richiedono formato senza trattini). ULID e NanoID non hanno trattini per impostazione predefinita e supportano anche il cambio di maiuscole/minuscole.
Perché usare uno strumento online invece della riga di comando per generare UUID?
Gli strumenti da riga di comando (come uuidgen di Linux, il modulo uuid di Python) richiedono un ambiente di sviluppo. Uno strumento online funziona istantaneamente nel tuo browser senza necessità di installazione. Inoltre, questo strumento integra il riconoscimento della versione UUID, l'esportazione in massa e funzionalità di cronologia locale: più conveniente quando si lavora su più dispositivi (ad esempio, generando ID per colleghi non tecnici) o quando hai bisogno di ID al volo.
Glossario
- UUID
- Universally Unique Identifier, lunghezza 128 bit, standard RFC 4122, le versioni comuni includono v1 (timestamp+MAC), v4 (casuale), v5 (hash SHA-1).
- GUID
- Globally Unique Identifier, termine di Microsoft per UUID: i due sono identici in formato e scopo.
- ULID
- Universally Unique Lexicographically Sortable Identifier, 26 caratteri che utilizzano la codifica Crockford Base32, i primi 48 bit sono timestamp: ordinabile per tempo di creazione.
- NanoID
- Un generatore di ID univoco leggero, 21 caratteri sicuri per gli URL per impostazione predefinita (A-Za-z0-9_-), più corto e veloce di UUID, ideale per scenari front-end e URL.
- UUID v1
- Versione UUID basata su timestamp e indirizzo MAC, ordinabile temporalmente ma può divulgare indirizzo MAC e tempo di generazione: meno sicura di v4.
- UUID v4
- Versione UUID completamente basata su numeri casuali, la più utilizzata, probabilità di collisione trascurabile, la scelta predefinita nello sviluppo.
- UUID v5
- Versione UUID con namespace basata su hash SHA-1: lo stesso namespace + lo stesso input di nome produce un output UUID identico, adatta a scenari deterministici.
- Probabilità di collisione
- La probabilità che due ID generati casualmente siano identici. La probabilità di collisione di UUID v4 è di circa 1 su 17 trilioni di trilioni, trascurabile nell'ingegneria pratica.
- Crockford Base32
- Una codifica Base32 progettata da Douglas Crockford che utilizza lettere maiuscole e cifre escludendo I/L/O/U per evitare caratteri ambigui: utilizzata da ULID.
Confronto UUID / ULID / NanoID
| Caratteristica | UUID v4 | ULID | NanoID |
|---|---|---|---|
| Lunghezza | 36 caratteri (con trattini) / 32 caratteri (senza trattini) | 26 caratteri | 21 caratteri (predefinito) |
| Set di caratteri | Esadecimale (0-9a-f) | Crockford Base32 (32 caratteri) | Sicuro per URL (64 caratteri) |
| Ordinabilità | Non ordinato (casuale) | Ordinato per tempo | Non ordinato (casuale) |
| Sicuro per URL | Richiede escape (trattini + alfanumerico) | Principalmente sicuro (maiuscole + cifre) | Completamente sicuro per URL |
| Velocità di generazione | Veloce | Veloce | ~60% più veloce di UUID |
| Probabilità di collisione | 1/10^36 | 1/10^36 | 1/10^34 (a 21 caratteri) |
| Casi d'uso tipici | Chiavi primarie DB, ID generali | Sistemi distribuiti, tracciamento log | URL brevi, ID front-end, cookie |
Metodi di generazione UUID per linguaggio
| Linguaggio | Codice |
|---|---|
| JavaScript | crypto.randomUUID() // Browser moderni / Node.js 19+ |
| Python | import uuid; uuid.uuid4() |
| Java | UUID.randomUUID() |
| Go | github.com/google/uuid; uuid.New() |
| Bash/Linux | uuidgen o cat /proc/sys/kernel/random/uuid |
Authoritative References
- IETFRFC 4122 - Specifica UUID
- GitHubSpecifica ULID (GitHub)
- OfficialSito ufficiale NanoID
- Simulatore Daltonismo
- Convertitore di colori
- Convertitore da .htaccess a Nginx
- Convertitore SQL
- Parser Cookie
- Generatore di Espressioni Cron
- Validatore di Espressioni Cron
- Formattazione CSS
- Compressione CSS
- Da CSV a Excel
- Convertitore di Valuta
- Confronto Testo
- Generatore Favicon
- Formattazione XML
- Convertitore Esadecimale
- Formattazione HTML
- Compressione HTML
- Da HTML a Markdown
- Da Markdown a HTML
- Formattazione JavaScript
- Compressione JS
- Formattatore JSX
- Compressione JSX
- Raggruppamento di parole chiave
- Generatore Lorem Ipsum
- Generatore Tabelle Markdown
- Generatore di Meta Tag
- Generatore di Password
- Verificatore di Sicurezza Password
- Generatore di QR Code/Codici a Barre
- Tester di Espressioni Regolari
- Generatore di Slug
- Costruttore Query SQL
- Formattatore SQL
- Contatore di Parole
- Strumento Orario
- Formattazione TypeScript
- Compressione TypeScript
- Formattazione TSX
- Compressione TSX
- Convertitore Unix Timestamp
- Generatore UUID
- Formattazione YAML
- Conversione dei casi