Walidator UUID

Waliduj pojedyncze identyfikatory lub całe listy UUID zgodnie z RFC 9562 lokalnie w przeglądarce.

Bez przesyłania plikówBez rejestracjiNatychmiastowe wyniki
Ścisłe RFC 9562 + filtry wersjiMasowa diagnostyka wiersz po wierszuRaport audytu JSON i CSV
Waliduj UUID
Silnik offline gotowy100% prywatna praca w przeglądarce • Bez wysyłania do chmury
100% prywatności • Zero wysyłania plików na serwer

Dlaczego warto używać darmowego Walidator UUID od Utiliome?

Stworzone od podstaw dla pełnej prywatności i natychmiastowego działania. Bez subskrypcji, opłat i rejestracji.

Pełna obsługa wszystkich wersji z RFC 9562

Waliduje nowoczesne identyfikatory UUIDv6, UUIDv7 i UUIDv8 obok klasycznych kluczy od v1 do v5 oraz specjalnych wartości Nil (same zera) i Max (same jedynki), które starsze wyrażenia regularne z RFC 4122 odrzucają.

Masowa klasyfikacja i filtrowanie wiersz po wierszu

Przetwarza tysiące kandydatów rozdzielonych znakami nowej linii w jednym przebiegu, oznaczając każdy wiersz wykrytą wersją, prefiksem wariantu i dokładnym błędem składni przed eksportem oczyszczonego zbioru.

Rygorystyczna weryfikacja wariantu i składni kanonicznej

Sprawdza dokładną 36-znakową strukturę szesnastkową 8-4-4-4-12 i odróżnia standardowe bity wariantu RFC 9562 (10xx) od starszych identyfikatorów Microsoft COM/GUID (110x), NCS (0xxx) oraz ciągów spoza zapisu hex.

W 100% lokalne przetwarzanie wsadowe w przeglądarce

Wykonuje weryfikację składni, normalizację do małych liter i filtrowanie całkowicie w karcie przeglądarki, bez przesyłania zrzutów baz danych, identyfikatorów klientów czy wycinków logów na zewnętrzne serwery.

Utiliome kontra tradycyjne narzędzia w chmurze

Porównaj nasz lokalny silnik WebAssembly ze starymi narzędziami chmurowymi.

Funkcja Utiliome (Lokalnie w przeglądarce) Tradycyjne konwertery chmurowe
Pełna obsługa wszystkich wersji z RFC 9562 Waliduje nowoczesne identyfikatory UUIDv6, UUIDv7 i UUIDv8 obok klasycznych kluczy od v1 do v5 oraz specjalnych wartości Nil (same zera) i Max (same jedynki), które starsze wyrażenia regularne z RFC 4122 odrzucają. Ograniczone opcje bez zaawansowanej konfiguracji
Masowa klasyfikacja i filtrowanie wiersz po wierszu Przetwarza tysiące kandydatów rozdzielonych znakami nowej linii w jednym przebiegu, oznaczając każdy wiersz wykrytą wersją, prefiksem wariantu i dokładnym błędem składni przed eksportem oczyszczonego zbioru. Wymaga zewnętrznych narzędzi lub ręcznej obróbki
Prywatność i przetwarzanie danych 100% lokalnie w przeglądarce (zero wysyłania na serwer) Przesyła dane na zewnętrzne serwery w chmurze
Cena i wymóg konta 100% za darmo na zawsze bez rejestracji Wymaga rejestracji konta lub płatnej subskrypcji
Jak to działa

Walidator UUID – instrukcja w 3 prostych krokach

Instalacja oprogramowania nie jest wymagana. Wszystko działa w Twojej przeglądarce.

1

Wklej testowane UUID lub wgraj plik

Wprowadź pojedynczy identyfikator UUID, wklej wielowierszową partię z logów aplikacji lub eksportu SQL albo upuść lokalny plik tekstowy lub CSV do walidatora.

2

Przejrzyj składnię, wersję i wariant dla każdego wiersza

Sprawdź podsumowanie wsadowe pokazujące liczbę poprawnych i błędnych wierszy, klasyfikację wersji (od v1 do v8, Nil, Max) oraz szczegółową diagnostykę odrzuconych pozycji.

3

Przefiltruj i wyeksportuj oczyszczone identyfikatory UUID

Zawęź wyniki do poprawnych identyfikatorów zgodnych z RFC 9562 lub do wybranej wersji UUID, a następnie skopiuj lub pobierz znormalizowaną listę zapisaną małymi literami.

Przewodnik po masowej walidacji UUID: Listy wejściowe i raport diagnostyczny

Szybka odpowiedź: Podczas walidacji wielowierszowej listy kandydatów każdy przycięty wiersz jest sprawdzany pod kątem kanonicznej 36-znakowej struktury szesnastkowej 8-4-4-4-12, najpierw porównywany ze specjalnymi stałymi Nil i Max, a następnie testowany w celu potwierdzenia, że półbajt (nibble) 13 koduje wersję 1-8, a półbajt 17 zaczyna się od bitów wariantu 10xx zgodnego z RFC 9562.

Potoki danych (data pipelines) i zadania ingestii API często napotykają mieszane formaty identyfikatorów — nowoczesne klucze UUIDv7, starsze identyfikatory GUID pisane wielkimi literami, stałe wartownicze (sentinel values) oraz tokeny niebędące UUID, takie jak ULID. Poniżej znajduje się konkretna siedmiowierszowa partia pokazująca, jak walidacja RFC 9562 klasyfikuje każdy przypadek.

Przykładowe wielowierszowe dane wejściowe

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

Raport klasyfikacji wiersz po wierszu

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

Przefiltrowany eksport kanoniczny

Eksport poprawnych wierszy normalizuje wielkie znaki szesnastkowe do kanonicznych małych liter zgodnie z sekcją 4 standardu RFC 9562:

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

Zasady walidacji RFC 9562, przypadki brzegowe Regex i normalizacja kanoniczna

Szybka odpowiedź: Walidator zgodny z RFC 9562 nie może polegać na przestarzałych wyrażeniach regularnych [1-5] z RFC 4122: musi akceptować wersje od 1 do 8 w parze z wariantem [89ab], jawnie dopuszczać złożony z samych zer Nil UUID oraz złożony z samych jedynek Max UUID, a także normalizować wielkie cyfry szesnastkowe do kanonicznych małych liter przed zapisem w indeksach tekstowych.

Standard RFC 9562 (maj 2024 r.) rozszerzył specyfikację UUID z pięciu wersji do ośmiu i sformalizował dwie stałe graniczne, dezaktualizując starsze wzorce walidacji wciąż zaszyte w wielu bibliotekach walidacyjnych i bramach API.

Dlaczego starsze wyrażenia regularne RFC 4122 odrzucają nowoczesne klucze

Walidatory sprzed 2024 roku powszechnie wymuszają zakres [1-5] na 13. cyfrze szesnastkowej i pomijają wartości wartownicze, odrzucając poprawne klucze UUIDv6, UUIDv7, UUIDv8, Nil oraz Max. Kompletne, niewrażliwe na wielkość liter wyrażenie regularne RFC 9562 dopasowujące kanoniczną składnię 8-4-4-4-12 dla wersji v1-v8 wraz z Nil i Max wygląda następująco:

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

Podczas walidacji niezaufanych danych wejściowych w środowiskach backendowych, takich jak Python, Ruby czy PCRE, zakotwicz koniec ciągu za pomocą \z (lub \Z w Pythonie przy użyciu re.fullmatch) zamiast $, ponieważ $ dopasowuje pozycję tuż przed końcowym znakiem nowej linii \n i może przepuścić ładunki z wstrzykniętym znakiem nowej linii przez proste testy tekstowe.

Typy bazodanowe `uuid` a rygorystyczne schematy aplikacji

Częstym źródłem błędów ingestii na produkcji jest rozbieżność między liberalnymi parserami baz danych a rygorystycznymi walidatorami schematów API:

  • Liberalne 128-bitowe parsery szesnastkowe (np. uuid w PostgreSQL): PostgreSQL akceptuje dowolne 32 cyfry szesnastkowe (z kanonicznymi myślnikami, opcjonalnymi nawiasami klamrowymi {...} lub zupełnie bez myślników) niezależnie od półbajtu wersji (0-f) czy prefiksu wariantu (0xxx, 10xx, 110x, 111x). Starsze identyfikatory GUID Microsoft COM (wariant 110x, znak szesnastkowy c lub d na 17. pozycji) lub dowolne 128-bitowe skróty MD5 zapisane w kolumnie uuid przechodzą operacje SQL INSERT bez błędu.
  • Rygorystyczne walidatory RFC 9562 (OpenAPI, Zod, Rust uuid, Go google/uuid): Ścisłe schematy API weryfikują kanoniczny 36-znakowy zapis z myślnikami i często wymuszają wariant 10xx oraz wersje 1-8 (plus Nil/Max). Masowa walidacja eksportów SQL przed ich ponownym przesłaniem do rygorystycznych usług REST lub gRPC pozwala wcześnie wychwycić wiersze z wariantami spoza RFC.

Kanoniczna normalizacja wielkości liter

Sekcja 4 standardu RFC 9562 wymaga, aby parsery akceptowały wielkie litery A-F na wejściu, ale generowały małe litery a-f na wyjściu. Natywne 16-bajtowe typy binarne w bazach danych (UUID w PostgreSQL, BINARY(16) w MySQL) automatycznie eliminują problem wielkości liter, jednak systemy przechowujące UUID w polach VARCHAR(36), kluczach Redis, kluczach partycji DynamoDB lub pamięciach podręcznych JSON traktują 550E8400-... oraz 550e8400-... jako dwa różne ciągi znaków, o ile nie zostaną one znormalizowane do małych liter podczas walidacji.

Walidator UUID vs Parser UUID vs Generator UUID: Którego narzędzia potrzebujesz?

Szybka odpowiedź: Użyj Walidatora UUID, aby zweryfikować składnię, sprawdzić zgodność z RFC 9562, sklasyfikować wersje na masowych listach i wyeksportować czyste identyfikatory. Użyj Parsera i dekodera UUID, aby wyodrębnić osadzone znaczniki czasu UTC i 128-bitowe pola z konkretnego klucza, lub Generatora UUID v4 online, aby utworzyć nowe, kryptograficznie losowe identyfikatory.

Wybierz odpowiednie narzędzie UUID w Utiliome w zależności od tego, czy przeprowadzasz audyt istniejących list, badasz wewnętrzne pola bitowe, czy generujesz nowe klucze:

Możliwość Walidator UUID (To narzędzie) Parser i dekoder UUID Generator UUID v4 online
Główne przeznaczenie Walidacja pojedynczych lub wielowierszowych partii UUID i odfiltrowywanie uszkodzonych wpisów Dekodowanie 128-bitowego układu binarnego UUID, identyfikatora węzła i osadzonego znacznika czasu UTC Masowe generowanie kryptograficznie losowych (CSPRNG) identyfikatorów UUIDv4
Przetwarzanie masowych list Tak — wklejanie list lub wgrywanie plików, diagnostyka każdego wiersza i eksport poprawnych zbiorów Nie — zaprojektowany do głębokiej inspekcji pól bitowych pojedynczych identyfikatorów Generuje nowe partie losowych kluczy v4; nie waliduje zewnętrznych danych wejściowych
Obsługiwane wersje Klasyfikuje wersje od v1 do v8, Nil (0000...) oraz Max (ffff...) Dekoduje struktury bitowe dla wersji od v1 do v8, Nil oraz Max Generuje wyłącznie UUIDv4 zgodne z RFC 9562 (do kluczy uporządkowanych czasowo użyj narzędzia Generator UUID v7, v6 i v1)
Ekstrakcja znacznika czasu Rozpoznaje, czy klucz jest oparty na czasie (v1, v6, v7), bez dekodowania dat Wyodrębnia dokładne daty ISO-8601 UTC, milisekundy Unix i 100-ns takty gregoriańskie Nie dotyczy (UUIDv4 zawiera 122 losowe bity i zero danych o czasie)

Zalecane przepływy pracy dla programistów

  • Oczyszczanie eksportów CSV, logów lub ładunków migracyjnych: Wklej tutaj swoją listę, aby oddzielić poprawne identyfikatory RFC 9562 od uszkodzonych ciągów, identyfikatorów ULID lub starszych kluczy GUID niezgodnych z RFC, i wyeksportuj czystą listę pisaną małymi literami.
  • Sprawdzanie, kiedy wygenerowano klucz oparty na czasie: Skopiuj dowolny poprawny identyfikator v1, v6 lub v7 do narzędzia Parser i dekoder UUID, aby zbadać osadzony w nim znacznik czasu utworzenia UTC, sekwencję zegara (clock sequence) i 128-bitowe pola binarne.
  • Generowanie nowych identyfikatorów: Użyj narzędzia Generator UUID v4 online, aby uzyskać nieprzewidywalne losowe tokeny, lub narzędzia Generator UUID v7, v6 i v1, aby utworzyć chronologicznie sortowalne klucze główne do baz danych.
FAQ

Walidator UUID – FAQ i przewodnik techniczny

Wszystko, co musisz wiedzieć o darmowym narzędziu online walidator uuid od Utiliome.

Czy Nil (same zera) i Max (same litery F) to poprawne identyfikatory UUID według RFC 9562?

Tak. Sekcja 5.9 standardu RFC 9562 definiuje 00000000-0000-0000-0000-000000000000 jako Nil UUID, a sekcja 5.10 definiuje ffffffff-ffff-ffff-ffff-ffffffffffff jako Max UUID na potrzeby wartości wartowniczych (sentinel values) i zapytań o górną granicę zakresu, mimo że ich półbajty wersji i wariantu wykraczają poza zakresy [1-8] oraz [89ab].

Dlaczego identyfikator GUID firmy Microsoft przechodzi w PostgreSQL, ale nie przechodzi rygorystycznej walidacji RFC 9562?

Starsze identyfikatory Microsoft COM/DCOM GUID mogą posiadać wariant kompatybilności wstecznej 110x (znak szesnastkowy c lub d na 17. pozycji hex) zamiast wariantu RFC 9562 10xx (8, 9, a, b). Natywny typ kolumny uuid w PostgreSQL akceptuje dowolną 128-bitową wartość szesnastkową bez sprawdzania bitów wersji czy wariantu, podczas gdy rygorystyczne walidatory RFC 9562 odrzucają warianty inne niż 10xx.

Czy wielkie litery w zapisie szesnastkowym sprawiają, że UUID jest niepoprawny?

Nie. Sekcja 4 standardu RFC 9562 stanowi, że parsery muszą akceptować wielkie litery A-F oraz małe litery a-f bez rozróżniania wielkości znaków podczas odczytu UUID, ale wymaga od generatorów i formaterów zwracania kanonicznego zapisu szesnastkowego małymi literami, aby indeksy tekstowe i mapy skrótów rozróżniające wielkość liter nie przechowywały zduplikowanych kluczy.

Dlaczego starsze wyrażenia regularne do walidacji UUID odrzucają UUID v7 i UUID v8?

Wzorce wyrażeń regularnych napisane dla RFC 4122 (opublikowanego w 2005 roku) mają na sztywno zakodowany zakres [1-5] na 13. cyfrze szesnastkowej, ponieważ przed majem 2024 roku istniały tylko wersje od 1 do 5. Dopiero standard RFC 9562 ustandaryzował przeorganizowany gregoriański format v6, uporządkowany według czasu epoki Uniksa format v7, niestandardowy format v8 oraz złożony z samych jedynek Max UUID.

Czy identyfikatory ULID, GUID w nawiasach klamrowych lub 32-znakowe ciągi hex bez myślników to poprawne kanoniczne UUID?

Nie w kanonicznej postaci tekstowej. Identyfikatory ULID kodują 128 bitów jako 26 znaków Crockford Base32 zamiast zapisu szesnastkowego, natomiast nawiasy klamrowe {...}, prefiksy urn:uuid: oraz 32-znakowe ciągi bez myślników to alternatywne opakowania transportowe; kanoniczna składnia UUID według RFC 9562 bezwzględnie wymaga 36 znaków sformatowanych jako cyfry szesnastkowe w układzie 8-4-4-4-12.