Validatore UUID

Valida singoli UUID o liste in blocco secondo RFC 9562 nel browser.

Nessun caricamentoNessuna registrazioneRisultati istantanei
RFC 9562 rigoroso + Filtri versioneDiagnostica massiva riga per rigaReport di audit JSON e CSV
Convalida UUID
Motore offline prontoSpazio di lavoro 100% privato nel browser • Zero upload in cloud
100% Privato • Nessun Caricamento File su Server

Perché usare il Validatore UUID gratuito di Utiliome?

Creato da zero per garantire massima privacy, esecuzione istantanea e zero intoppi. Senza abbonamento né registrazione.

Copertura Completa delle Versioni RFC 9562

Valida i moderni identificatori UUIDv6, UUIDv7 e UUIDv8 insieme alle classiche chiavi da v1 a v5 e agli UUID speciali Nil (tutti zeri) e Max (tutti uno), spesso rifiutati dalle regex legacy basate su RFC 4122.

Classificazione e Filtro in Blocco Riga per Riga

Elabora migliaia di stringhe candidate delimitate da a capo in un unico passaggio, etichettando ogni riga con la versione rilevata, il prefisso della variante e l'esatto errore di sintassi prima di esportare i set validi bonificati.

Controlli Rigorosi su Variante e Sintassi Canonica

Verifica l'esatta struttura esadecimale di 36 caratteri in formato 8-4-4-4-12 e distingue i bit di variante standard RFC 9562 (10xx) dai formati legacy Microsoft COM/GUID (110x), NCS (0xxx) e dai token non esadecimali.

Elaborazione Batch 100% Locale nel Browser

Esegue verifica sintattica, normalizzazione in minuscolo e filtraggio interamente nella scheda del browser, senza mai caricare dump di database, ID clienti o estratti di log su server esterni.

Utiliome vs le alternative cloud tradizionali

Confronta il nostro motore locale WebAssembly con i vecchi strumenti in cloud.

Funzionalità Utiliome (Browser Locale) Convertitori Cloud Datati
Copertura Completa delle Versioni RFC 9562 Valida i moderni identificatori UUIDv6, UUIDv7 e UUIDv8 insieme alle classiche chiavi da v1 a v5 e agli UUID speciali Nil (tutti zeri) e Max (tutti uno), spesso rifiutati dalle regex legacy basate su RFC 4122. Opzioni limitate senza personalizzazione avanzata
Classificazione e Filtro in Blocco Riga per Riga Elabora migliaia di stringhe candidate delimitate da a capo in un unico passaggio, etichettando ogni riga con la versione rilevata, il prefisso della variante e l'esatto errore di sintassi prima di esportare i set validi bonificati. Richiede strumenti esterni o modifiche manuali
Privacy e Elaborazione Dati Elaborazione 100% locale nel browser (zero upload) Carica i dati su server cloud di terze parti
Prezzo e Registrazione 100% gratuito per sempre senza registrazione Richiede registrazione o abbonamento a pagamento
Come funziona

Come usare Validatore UUID in 3 semplici passaggi

Nessuna installazione richiesta. Tutto viene eseguito direttamente nel tuo browser web.

1

Incolla gli UUID Candidati o Carica un File

Inserisci un singolo UUID, incolla un blocco multiriga estratto da log applicativi o esportazioni SQL, oppure trascina un file di testo o CSV locale nel validatore.

2

Controlla Sintassi, Versione e Variante per Riga

Esamina il riepilogo del batch con il conteggio delle righe valide e non valide, la classificazione della versione per riga (da v1 a v8, Nil, Max) e la diagnostica specifica per le righe scartate.

3

Filtra ed Esporta gli UUID Bonificati

Filtra i risultati mantenendo solo gli identificatori RFC 9562 validi o una specifica versione di UUID, quindi copia o scarica la lista normalizzata in minuscolo.

Esempio Pratico di Validazione UUID in Blocco: Liste di Input e Output Diagnostico

Risposta Rapida: Durante la validazione di una lista multiriga di identificatori candidati, ogni riga ripulita dagli spazi viene confrontata con la struttura esadecimale canonica di 36 caratteri 8-4-4-4-12, verificata prima rispetto alle costanti speciali Nil e Max e poi testata per confermare che il nibble 13 codifichi una versione da 1 a 8 e il nibble 17 inizi con i bit di variante RFC 9562 10xx.

Le pipeline di dati e i job di ingestione API incontrano frequentemente formati di identificatori misti: chiavi UUIDv7 moderne, GUID legacy in maiuscolo, costanti sentinella e token non-UUID come gli ULID. Di seguito è riportato un batch concreto di sette righe che dimostra come la validazione RFC 9562 classifica ciascun caso.

Esempio di Input Candidato Multiriga

01941f29-7c7b-7a3c-9f4e-2b8d5c1a0e6f
550e8400-e29b-41d4-a716-446655440000
00000000-0000-0000-0000-000000000000
FFFFFFFF-FFFF-FFFF-FFFF-FFFFFFFFFFFF
550e8400-e29b-91d4-a716-446655440000
550e8400-e29b-41d4-c716-446655440000
01ARZ3NDEKTSV4RRFFQ69G5FAV

Report di Classificazione per Riga

[
  {
    "line": 1,
    "input": "01941f29-7c7b-7a3c-9f4e-2b8d5c1a0e6f",
    "valid": true,
    "classification": "UUIDv7",
    "variant": "RFC 9562 (10xx)",
    "normalized": "01941f29-7c7b-7a3c-9f4e-2b8d5c1a0e6f"
  },
  {
    "line": 2,
    "input": "550e8400-e29b-41d4-a716-446655440000",
    "valid": true,
    "classification": "UUIDv4",
    "variant": "RFC 9562 (10xx)",
    "normalized": "550e8400-e29b-41d4-a716-446655440000"
  },
  {
    "line": 3,
    "input": "00000000-0000-0000-0000-000000000000",
    "valid": true,
    "classification": "Nil UUID (RFC 9562 Section 5.9)",
    "variant": "Nil (all zeros)",
    "normalized": "00000000-0000-0000-0000-000000000000"
  },
  {
    "line": 4,
    "input": "FFFFFFFF-FFFF-FFFF-FFFF-FFFFFFFFFFFF",
    "valid": true,
    "classification": "Max UUID (RFC 9562 Section 5.10)",
    "variant": "Max (all ones)",
    "normalized": "ffffffff-ffff-ffff-ffff-ffffffffffff"
  },
  {
    "line": 5,
    "input": "550e8400-e29b-91d4-a716-446655440000",
    "valid": false,
    "error": "Invalid version nibble '9' at position 15 (expected 1-8, or Nil/Max)"
  },
  {
    "line": 6,
    "input": "550e8400-e29b-41d4-c716-446655440000",
    "valid": false,
    "error": "Non-RFC-9562 variant nibble 'c' (110x Microsoft legacy GUID; expected 8, 9, a, or b)"
  },
  {
    "line": 7,
    "input": "01ARZ3NDEKTSV4RRFFQ69G5FAV",
    "valid": false,
    "error": "Invalid length (26 chars, Crockford Base32 ULID pattern; expected 36-char 8-4-4-4-12 hex)"
  }
]

Esportazione Canonica Filtrata

L'esportazione delle righe valide normalizza i caratteri esadecimali maiuscoli nel formato canonico minuscolo previsto dalla Sezione 4 dell'RFC 9562:

01941f29-7c7b-7a3c-9f4e-2b8d5c1a0e6f
550e8400-e29b-41d4-a716-446655440000
00000000-0000-0000-0000-000000000000
ffffffff-ffff-ffff-ffff-ffffffffffff

Regole di Validazione RFC 9562, Casi Limite delle Regex e Normalizzazione Canonica

Risposta Rapida: Un validatore conforme a RFC 9562 non può affidarsi alle vecchie regex [1-5] dell'RFC 4122: deve accettare le versioni da 1 a 8 abbinate alla variante [89ab], includendo esplicitamente nella whitelist gli UUID Nil (tutti zeri) e Max (tutti uno), e normalizzare le cifre esadecimali maiuscole in minuscolo canonico prima dell'archiviazione indicizzata come stringa.

Lo standard RFC 9562 (maggio 2024) ha ampliato la specifica UUID da cinque a otto versioni e ha formalizzato due costanti limite, rendendo obsoleti i pattern di validazione precedenti ancora integrati in molte librerie e API gateway.

Perché le Regex Legacy RFC 4122 Falliscono sulle Chiavi Moderne

I validatori antecedenti al 2024 impongono comunemente [1-5] sulla tredicesima cifra esadecimale e omettono i valori sentinella, rifiutando chiavi UUIDv6, UUIDv7, UUIDv8, Nil e Max perfettamente valide. Un'espressione regolare RFC 9562 completa e case-insensitive che riconosce la sintassi canonica 8-4-4-4-12 per le versioni v1-v8 oltre a Nil e Max è:

^(?:[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|[fF]{8}-[fF]{4}-[fF]{4}-[fF]{4}-[fF]{12})$

Quando si valida input non attendibile in runtime backend come Python, Ruby o PCRE, è consigliabile ancorare la fine della stringa con \z (oppure \Z usando re.fullmatch in Python) anziché $, poiché $ corrisponde anche alla posizione immediatamente precedente a un carattere di ritorno a capo \n finale e può lasciar passare payload con newline iniettati nei controlli superficiali.

Tipi `uuid` dei Database vs Schemi Applicativi Rigorosi

Una causa frequente di errori di ingestione in produzione è la discrepanza tra parser di database permissivi e validatori di schemi API rigorosi:

  • Parser Esadecimali a 128 Bit Permissivi (es. PostgreSQL uuid): PostgreSQL accetta qualsiasi sequenza di 32 cifre esadecimali (con trattini canonici, parentesi graffe {...} opzionali o senza trattini) indipendentemente dal nibble della versione (0-f) o dal prefisso della variante (0xxx, 10xx, 110x, 111x). I GUID Microsoft COM legacy (variante 110x, esadecimale c o d alla 17ª cifra) o digest MD5 arbitrari a 128 bit salvati in una colonna uuid superano le istruzioni SQL INSERT senza errori.
  • Validatori RFC 9562 Rigorosi (OpenAPI, Zod, Rust uuid, Go google/uuid): Gli schemi API rigorosi verificano la separazione canonica con trattini a 36 caratteri e spesso impongono la variante 10xx e le versioni 1-8 (più Nil/Max). Validare in blocco le esportazioni SQL prima di inviarle a servizi REST o gRPC rigorosi permette di intercettare in anticipo le righe con varianti non conformi.

Normalizzazione Canonica in Minuscolo

La Sezione 4 dell'RFC 9562 stabilisce che i parser accettino caratteri maiuscoli A-F in ingresso ma producano caratteri minuscoli a-f in uscita. I tipi binari nativi a 16 byte nei database (UUID in PostgreSQL, BINARY(16) in MySQL) eliminano automaticamente la distinzione tra maiuscole e minuscole, ma i sistemi che memorizzano gli UUID in campi VARCHAR(36), chiavi Redis, partition key di DynamoDB o cache JSON trattano 550E8400-... e 550e8400-... come stringhe distinte se non vengono normalizzati in minuscolo durante la validazione.

Validatore UUID vs Parser UUID vs Generatore UUID: Quale Strumento Scegliere?

Risposta Rapida: Usa il Validatore UUID per verificare la sintassi, controllare la conformità RFC 9562, classificare le versioni su liste in blocco ed esportare ID puliti. Usa il Parser e Decodificatore UUID per estrarre i timestamp UTC incorporati e i campi a 128 bit da uno specifico UUID, oppure il Generatore UUID v4 per creare nuovi identificatori casuali crittograficamente sicuri.

Scegli l'utility UUID di Utiliome più adatta in base alla tua attività: revisione di liste esistenti, ispezione dei campi di bit interni o generazione di nuove chiavi:

Funzionalità Validatore UUID (Questo Strumento) Parser e Decodificatore UUID Generatore UUID v4
Obiettivo Principale Validare singoli UUID o batch multiriga e filtrare le voci malformate Decodificare il layout binario a 128 bit di un UUID, il node ID e il timestamp UTC incorporato Generare in blocco identificatori UUIDv4 casuali crittograficamente sicuri (CSPRNG)
Elaborazione Liste in Blocco Sì — incolla liste o carica file, visualizza la diagnostica per riga ed esporta i set validi No — progettato per l'ispezione approfondita dei campi di bit di singoli identificatori Produce nuovi blocchi di chiavi casuali v4; non valida input esterni
Copertura Versioni Classifica da v1 a v8, Nil (0000...) e Max (ffff...) Decodifica le strutture di bit da v1 a v8, Nil e Max Genera esclusivamente UUIDv4 RFC 9562 (usa il Generatore UUID v7, v6 e v1 per chiavi ordinate nel tempo)
Estrazione Timestamp Identifica se una chiave è basata sul tempo (v1, v6, v7) senza decodificare le date Estrae date UTC ISO-8601 esatte, millisecondi Unix e tick gregoriani da 100 ns Non applicabile (UUIDv4 contiene 122 bit casuali e nessun dato temporale)

Flussi di Lavoro Consigliati per Sviluppatori

  • Bonifica di esportazioni CSV, log o payload di migrazione: Incolla qui la tua lista per separare gli identificatori RFC 9562 validi da stringhe corrotte, ULID o GUID legacy non conformi ed esportare un elenco pulito in minuscolo.
  • Analisi del momento di creazione di una chiave temporale: Copia qualsiasi identificatore v1, v6 o v7 valido nel Parser e Decodificatore UUID per ispezionare il timestamp di creazione UTC incorporato, la clock sequence e i campi binari a 128 bit.
  • Generazione di nuovi identificatori: Usa il Generatore UUID v4 per token casuali imprevedibili, oppure il Generatore UUID v7, v6 e v1 per chiavi primarie di database ordinabili cronologicamente.
Domande frequenti

FAQ e Guida Tecnica su Validatore UUID

Tutto ciò che devi sapere sull'uso di validatore uuid online e gratuito di Utiliome.

Gli UUID Nil (tutti zeri) e Max (tutte F) sono validi secondo lo standard RFC 9562?

Sì. La Sezione 5.9 dell'RFC 9562 definisce 00000000-0000-0000-0000-000000000000 come UUID Nil, mentre la Sezione 5.10 definisce ffffffff-ffff-ffff-ffff-ffffffffffff come UUID Max per valori sentinella e query di intervallo sul limite superiore, anche se i rispettivi nibble di versione e variante non rientrano in [1-8] e [89ab].

Perché un GUID Microsoft viene accettato in PostgreSQL ma fallisce la validazione rigorosa RFC 9562?

I GUID Microsoft COM/DCOM legacy possono utilizzare la variante di retrocompatibilità 110x (cifra esadecimale c o d in 17ª posizione) anziché la variante RFC 9562 10xx (8, 9, a, b). Il tipo di colonna nativo uuid di PostgreSQL accetta qualsiasi valore esadecimale a 128 bit senza controllare i bit di versione o variante, mentre i validatori RFC 9562 rigorosi segnalano le varianti diverse da 10xx.

Le lettere esadecimali maiuscole rendono un UUID non valido?

No. La Sezione 4 dell'RFC 9562 stabilisce che i parser devono accettare sia maiuscole A-F sia minuscole a-f in modo case-insensitive durante la lettura degli UUID, ma richiede che generatori e formattatori producano testo esadecimale canonico in minuscolo per evitare che indici di stringhe e hash map case-sensitive memorizzino chiavi duplicate.

Perché le vecchie regex di validazione UUID rifiutano UUID v7 e UUID v8?

I pattern regex scritti per lo standard RFC 4122 (pubblicato nel 2005) vincolano rigidamente [1-5] sulla 13ª cifra esadecimale poiché prima di maggio 2024 esistevano solo le versioni da 1 a 5; con l'RFC 9562 sono stati standardizzati gli UUID gregoriani riordinati v6, quelli ordinati temporalmente su Unix Epoch v7, il formato personalizzato v8 e l'UUID Max con tutti i bit a uno.

Gli ULID, i GUID tra parentesi graffe o le stringhe esadecimali di 32 caratteri senza trattini sono UUID canonici validi?

Non nella forma testuale canonica. Gli ULID codificano 128 bit in 26 caratteri Base32 di Crockford anziché in esadecimale, mentre le parentesi graffe {...}, i prefissi urn:uuid: e le stringhe di 32 caratteri senza trattini sono wrapper di trasporto alternativi; la sintassi canonica UUID dell'RFC 9562 richiede rigorosamente 36 caratteri formattati come cifre esadecimali 8-4-4-4-12.