UUID-validerare

Validera enskilda eller tusentals UUID-strängar mot RFC 9562 lokalt i webbläsaren.

Inga uppladdningarIngen registreringOmedelbara resultat
Strikt RFC 9562 + versionsfilterRad-för-rad-diagnostik i bulkJSON- & CSV-granskningsrapport
Validera UUID
Offlinemotorn är redo100 % privat arbetsyta i webbläsaren • Inga molnuppladdningar
100 % Privat • Ingen filuppladdning till server

Varför använda Utiliomes gratis UUID-validerare?

Byggd från grunden för strikt integritet, snabb körning och utan krångel. Inga prenumerationer eller konton krävs.

Fullständigt stöd för alla RFC 9562-versioner

Validerar moderna UUIDv6-, UUIDv7- och UUIDv8-identifierare tillsammans med klassiska v1–v5-nycklar samt specialvärdena Nil (alla nollor) och Max (alla ettor) som äldre RFC 4122-regexar avvisar.

Radvis klassificering och filtrering i bulk

Bearbetar tusentals radbrytningsseparerade strängar i en körning, märker varje rad med detekterad version, variantprefix och exakt syntaxfel innan rensade och giltiga listor exporteras.

Strikt kontroll av variantbitar och kanonisk syntax

Verifierar den exakta hexadecimala strukturen på 36 tecken (8-4-4-4-12) och skiljer standardiserade RFC 9562-variantbitar (10xx) från äldre Microsoft COM/GUID (110x), NCS (0xxx) och icke-hexadecimala strängar.

100 % lokal batchbearbetning i webbläsaren

Kör syntaxkontroll, normalisering till gemener och filtrering helt i din webbläsarflik utan att ladda upp databasdumpar, kund-ID:n eller loggutdrag till externa servrar.

Utiliome jämfört med molnalternativ

Jämför vår lokala WebAssembly-motor med äldre molnverktyg.

Funktion Utiliome (Lokal webbläsare) Traditionella molnomvandlare
Fullständigt stöd för alla RFC 9562-versioner Validerar moderna UUIDv6-, UUIDv7- och UUIDv8-identifierare tillsammans med klassiska v1–v5-nycklar samt specialvärdena Nil (alla nollor) och Max (alla ettor) som äldre RFC 4122-regexar avvisar. Begränsade alternativ utan avancerad anpassning
Radvis klassificering och filtrering i bulk Bearbetar tusentals radbrytningsseparerade strängar i en körning, märker varje rad med detekterad version, variantprefix och exakt syntaxfel innan rensade och giltiga listor exporteras. Kräver externa verktyg eller manuell hantering
Integritet och databehandling 100 % lokalt i webbläsaren (ingen serveruppladdning) Laddar upp data till externa molnservrar
Pris och kontokrav 100 % gratis för alltid utan registrering Kräver kontoregistrering eller betald prenumeration
Så fungerar det

Hur du använder UUID-validerare i 3 enkla steg

Ingen programinstallation krävs. Allt körs direkt i din webbläsare.

1

Klistra in UUID-kandidater eller ladda upp en fil

Ange ett enskilt UUID, klistra in en flerradig lista från applikationsloggar eller SQL-exporter, eller släpp en lokal text- eller CSV-fil i valideraren.

2

Granska syntax, version och variant per rad

Inspektera sammanfattningen med antal giltiga respektive ogiltiga rader, versionsklassificering per rad (v1 till v8, Nil, Max) och specifik feldiagnostik för avvisade rader.

3

Filtrera och exportera rensade UUID:n

Filtrera resultaten till giltiga RFC 9562-identifierare eller en specifik UUID-version, och kopiera eller ladda sedan ner den normaliserade listan i gemener.

Genomgång av UUID-validering i bulk: Indatalistor och diagnostisk utdata

Snabbsvar: När en flerradig lista med kandidatidentifierare valideras kontrolleras varje trimmad rad mot den kanoniska hexadecimala strukturen på 36 tecken (8-4-4-4-12), matchas först mot specialkonstanterna Nil och Max, och testas därefter för att bekräfta att nibble 13 kodar version 1–8 och att nibble 17 inleds med variantbitarna 10xx enligt RFC 9562.

Datapipelines och API-inläsningsjobb stöter ofta på blandade identifierarformat – moderna UUIDv7-nycklar, äldre GUID:ar i versaler, gränsvärdeskonstanter och icke-UUID-strängar som ULID. Nedan visas en konkret batch på sju rader som demonstrerar hur RFC 9562-validering klassificerar varje fall.

Exempel på flerradig indatalista

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

Klassificeringsrapport per rad

[
  {
    "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)"
  }
]

Filtrerad kanonisk export

Vid export av giltiga rader normaliseras versala hexadecimala tecken till kanoniska gemener enligt RFC 9562 avsnitt 4:

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

Valideringsregler i RFC 9562, regex-specialfall och kanonisk normalisering

Snabbsvar: En kompatibel RFC 9562-validerare kan inte förlita sig på äldre RFC 4122-regexar med [1-5]: den måste acceptera versionerna 1 till 8 i kombination med variant [89ab] samt explicit tillåta Nil UUID (alla nollor) och Max UUID (alla ettor), och normalisera versala hex-siffror till kanoniska gemener före strängindexerad lagring.

RFC 9562 (maj 2024) utökade UUID-specifikationen från fem versioner till åtta och formaliserade två gränsvärdeskonstanter, vilket gjorde äldre valideringsmönster i många bibliotek och API-gateways föråldrade.

Varför äldre RFC 4122-regexar misslyckas på moderna nycklar

Validerare skrivna före 2024 kräver vanligtvis [1-5] på den 13:e hexadecimala siffran och utelämnar gränsvärden, vilket leder till att giltiga UUIDv6-, UUIDv7-, UUIDv8-, Nil- och Max-nycklar avvisas. Ett komplett, skiftlägesokänsligt reguljärt uttryck för RFC 9562 som matchar kanonisk 8-4-4-4-12-syntax för v1–v8 samt Nil och Max ser ut så här:

^(?:[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})$

När du validerar opålitlig indata i backend-miljöer som Python, Ruby eller PCRE bör du förankra slutet av strängen med \z (eller \Z med re.fullmatch i Python) i stället för $, eftersom $ även matchar precis före ett avslutande radbrytningstecken (\n) och därmed kan släppa igenom nyttolaster med radbrytningsinjektion vid naiva strängkontroller.

Databasers `uuid`-typer kontra strikta applikationsscheman

En vanlig orsak till inläsningsfel i produktion är diskrepansen mellan tillåtande databastolkare och strikta API-schemavaliderare:

  • Tillåtande 128-bitars hex-tolkare (t.ex. PostgreSQL uuid): PostgreSQL accepterar alla 32 hexadecimala siffror (med kanoniska bindestreck, valfria {...}-klammerparenteser eller helt utan bindestreck) oavsett versionsnibble (0–f) eller variantprefix (0xxx, 10xx, 110x, 111x). Äldre Microsoft COM GUID:ar (110x-variant, hex c eller d på siffra 17) eller godtyckliga 128-bitars MD5-kontrollsummor lagrade i en uuid-kolumn passerar SQL-inläggningar utan fel.
  • Strikta RFC 9562-validerare (OpenAPI, Zod, Rust uuid, Go google/uuid): Strikta API-scheman verifierar kanonisk bindestrecksformatering på 36 tecken och kräver ofta variant 10xx samt versionerna 1–8 (plus Nil/Max). Genom att validera SQL-exporter i bulk innan de spelas upp mot strikta REST- eller gRPC-tjänster fångar du upp rader med icke-RFC-varianter tidigt.

Kanonisk skiftlägesnormalisering

RFC 9562 avsnitt 4 föreskriver att tolkare måste acceptera versaler (A–F) vid inläsning men producera gemener (a–f) vid utmatning. Inbyggda binära databastyper på 16 byte (UUID i PostgreSQL, BINARY(16) i MySQL) eliminerar skiftläge automatiskt, men system som lagrar UUID:n i VARCHAR(36), Redis-nycklar, DynamoDB-partitionsnycklar eller JSON-cacher behandlar 550E8400-... och 550e8400-... som två skilda strängar om de inte normaliseras till gemener under valideringen.

UUID-validerare vs UUID-tolkare vs UUID-generator: Vilket verktyg behöver du?

Snabbsvar: Använd UUID-valideraren för att verifiera syntax, kontrollera efterlevnad av RFC 9562, klassificera versioner i bulklistor och exportera rena ID:n. Använd UUID-tolkare & Avkodare för att extrahera inbäddade UTC-tidsstämplar och 128-bitarsfält från ett specifikt UUID, eller UUID v4-generator för att skapa nya kryptografiskt slumpmässiga identifierare.

Välj rätt UUID-verktyg hos Utiliome beroende på om du granskar befintliga listor, inspekterar interna bitfält eller genererar nya nycklar:

Funktion UUID-validerare (Detta verktyg) UUID-tolkare & Avkodare UUID v4-generator
Primärt syfte Validera enskilda eller flerradiga UUID-batchar och filtrera bort felformaterade poster Avkoda ett UUID:s binära 128-bitarslayout, nod-ID och inbäddade UTC-tidsstämpel Generera kryptografiskt slumpmässiga (CSPRNG) UUIDv4-identifierare i bulk
Bearbetning av bulklistor Ja – klistra in listor eller ladda upp filer, se diagnostik per rad och exportera giltiga mängder Nej – utformad för djupgående bitfältsinspektion av enskilda identifierare Matar ut nya batchar av slumpmässiga v4-nycklar; validerar inte extern indata
Versionsstöd Klassificerar v1 till v8, Nil (0000...) och Max (ffff...) Avkodar bitstrukturer för v1 till v8, Nil och Max Genererar uteslutande RFC 9562 UUIDv4 (använd UUID v7, v6 & v1-generator för tidsordnade nycklar)
Extrahering av tidsstämpel Identifierar om en nyckel är tidsbaserad (v1, v6, v7) utan att avkoda datum Extraherar exakta ISO-8601 UTC-datum, Unix-ms och gregorianska 100-ns-intervall Ej tillämpligt (UUIDv4 innehåller 122 slumpmässiga bitar och ingen tidsstämpeldata)

Rekommenderade arbetsflöden för utvecklare

  • Tvätta CSV-exporter, loggar eller migreringsdata: Klistra in din lista här för att skilja giltiga RFC 9562-identifierare från skadade strängar, ULID:n eller äldre icke-RFC GUID:ar och exportera en ren lista i gemener.
  • Undersöka när en tidsbaserad nyckel skapades: Kopiera valfri giltig v1-, v6- eller v7-identifierare till UUID-tolkare & Avkodare för att inspektera dess inbäddade UTC-tidsstämpel, klocksekvens och binära 128-bitarsfält.
  • Generera nya identifierare: Använd UUID v4-generator för oförutsägbara slumpmässiga token, eller UUID v7, v6 & v1-generator för kronologiskt sorterbara primärnycklar i databaser.
FAQ

UUID-validerare FAQ och teknisk guide

Allt du behöver veta om att använda Utiliomes gratis uuid validerare online.

Är Nil (alla nollor) och Max (alla F) giltiga UUID:n enligt RFC 9562?

Ja. RFC 9562 avsnitt 5.9 definierar 00000000-0000-0000-0000-000000000000 som Nil UUID, och avsnitt 5.10 definierar ffffffff-ffff-ffff-ffff-ffffffffffff som Max UUID för gränsvärden och övre gränser i intervallfrågor, trots att deras versions- och variantnibbles ligger utanför [1-8] och [89ab].

Varför fungerar en Microsoft GUID i PostgreSQL men nekas vid strikt RFC 9562-validering?

Äldre Microsoft COM/DCOM GUID:ar kan ha bakåtkompatibilitetsvarianten 110x (hex c eller d på den 17:e hexadecimala siffran) i stället för RFC 9562-varianten 10xx (8, 9, a, b). PostgreSQL:s inbyggda kolumntyp uuid accepterar alla 128-bitars hexadecimala värden utan att kontrollera versions- eller variantbitar, medan strikta RFC 9562-validerare flaggar varianter som inte är 10xx.

Gör versala hexadecimala bokstäver ett UUID ogiltigt?

Nej. RFC 9562 avsnitt 4 anger att tolkare måste acceptera versaler (A–F) och gemener (a–f) skiftlägesokänsligt vid läsning av UUID:n, samtidigt som generatorer och formaterare måste mata ut kanoniska hexadecimala gemener så att skiftlägeskänsliga strängindex och hashtabeller inte lagrar dubblettnycklar.

Varför avvisar äldre UUID-valideringsregexar UUID v7 och UUID v8?

Regexmönster skrivna för RFC 4122 (publicerad 2005) hårdkodar [1-5] på den 13:e hexadecimala siffran eftersom endast versionerna 1 till 5 existerade före maj 2024, då RFC 9562 standardiserade omordnade gregorianska v6, Unix Epoch-tidsordnade v7, anpassade v8 samt Max UUID med bara ettor.

Är ULID:n, GUID:ar med klammerparenteser eller 32-teckens hex-strängar utan bindestreck giltiga kanoniska UUID:n?

Inte i kanonisk textform. ULID:n kodar 128 bitar som 26 Crockford Base32-tecken i stället för hexadecimalt, medan {...}-klammerparenteser, urn:uuid:-prefix och 32-teckenssträngar utan bindestreck är alternativa transportomslag; kanonisk UUID-syntax enligt RFC 9562 kräver strikt 36 tecken formaterade som 8-4-4-4-12 hexadecimala siffror.