Validateur d'UUID

Validez des UUID uniques ou en masse selon la RFC 9562 dans le navigateur.

Aucun téléversementSans inscriptionRésultats instantanés
RFC 9562 strict + Filtres de versionDiagnostic ligne par ligne en lotRapport d'audit JSON et CSV
Valider les UUID
Moteur hors ligne prêtEspace 100% privé dans le navigateur • Aucun transfert cloud
100 % Privé • Aucun fichier envoyé sur un serveur

Pourquoi utiliser Validateur d'UUID gratuitement sur Utiliome ?

Conçu pour garantir une confidentialité stricte, sans inscription ni abonnement requis.

Prise en charge complète des versions RFC 9562

Valide les identifiants modernes UUIDv6, UUIDv7 et UUIDv8 ainsi que les clés classiques v1 à v5 et les UUID spéciaux Nil (tout à zéro) et Max (tout à un) que les anciennes expressions régulières RFC 4122 rejettent.

Classification et filtrage en masse ligne par ligne

Traite des milliers de chaînes candidates séparées par des sauts de ligne en une seule passe, en étiquetant chaque ligne avec sa version détectée, son préfixe de variante et l'erreur de syntaxe exacte avant d'exporter des lots valides nettoyés.

Vérifications strictes de variante et de syntaxe canonique

Vérifie la structure hexadécimale exacte de 36 caractères au format 8-4-4-4-12 et distingue les bits de variante standard RFC 9562 (10xx) des anciens formats Microsoft COM/GUID (110x), NCS (0xxx) et des jetons non hexadécimaux.

Traitement par lots 100 % local dans le navigateur

Exécute la vérification syntaxique, la normalisation en minuscules et le filtrage entièrement dans votre onglet de navigateur sans téléverser d'exports de bases de données, d'identifiants clients ou d'extraits de journaux vers des serveurs externes.

Utiliome vs alternatives cloud traditionnelles

Comparez notre moteur local WebAssembly aux outils cloud anciens.

Fonctionnalité Utiliome (Navigateur local) Convertisseurs cloud anciens
Prise en charge complète des versions RFC 9562 Valide les identifiants modernes UUIDv6, UUIDv7 et UUIDv8 ainsi que les clés classiques v1 à v5 et les UUID spéciaux Nil (tout à zéro) et Max (tout à un) que les anciennes expressions régulières RFC 4122 rejettent. Options limitées sans personnalisation avancée
Classification et filtrage en masse ligne par ligne Traite des milliers de chaînes candidates séparées par des sauts de ligne en une seule passe, en étiquetant chaque ligne avec sa version détectée, son préfixe de variante et l'erreur de syntaxe exacte avant d'exporter des lots valides nettoyés. Nécessite des outils externes ou un traitement manuel
Confidentialité et Traitement 100 % local dans le navigateur (zéro envoi serveur) Envoie les données vers des serveurs cloud tiers
Tarif et Inscription 100 % gratuit à vie, sans compte ni filigrane Inscription obligatoire ou abonnement payant
Comment ça marche

Comment utiliser Validateur d'UUID en 3 étapes simples

Aucune installation requise. Tout s'exécute directement dans votre navigateur web.

1

Collez des UUID candidats ou importez un fichier

Saisissez un seul UUID, collez un lot multiligne issu de journaux d'application ou d'exports SQL, ou déposez un fichier texte ou CSV local dans le validateur.

2

Examinez la syntaxe, la version et la variante par ligne

Inspectez le résumé du lot affichant le nombre de lignes valides et invalides, la classification de version par ligne (v1 à v8, Nil, Max) et les diagnostics précis pour les lignes rejetées.

3

Filtrez et exportez les UUID nettoyés

Filtrez les résultats pour ne garder que les identifiants RFC 9562 valides ou une version d'UUID spécifique, puis copiez ou téléchargez la liste normalisée en minuscules.

Exemple de validation d'UUID en masse : listes d'entrée et rapport de diagnostic

Réponse rapide: Lors de la validation d'une liste multiligne d'identifiants candidats, chaque ligne nettoyée des espaces superflus est comparée à la structure hexadécimale canonique de 36 caractères 8-4-4-4-12, testée d'abord par rapport aux constantes spéciales Nil et Max, puis analysée pour confirmer que le quartet 13 encode une version de 1 à 8 et que le quartet 17 commence par les bits de variante 10xx de la RFC 9562.

Les pipelines de données et les tâches d'ingestion d'API rencontrent fréquemment des formats d'identifiants mixtes : clés UUIDv7 modernes, anciens GUID en majuscules, constantes sentinelles et jetons non-UUID comme les ULID. Voici un lot concret de sept lignes illustrant comment la validation RFC 9562 classe chaque cas.

Exemple d'entrée candidate multiligne

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

Rapport de classification ligne par ligne

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

Export canonique filtré

L'exportation des lignes valides normalise les caractères hexadécimaux majuscules en minuscules canoniques conformément à la section 4 de la RFC 9562 :

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

Règles de validation RFC 9562, cas limites de Regex et normalisation canonique

Réponse rapide: Un validateur conforme à la RFC 9562 ne peut pas se fier aux anciennes expressions régulières [1-5] de la RFC 4122 : il doit accepter les versions 1 à 8 associées à la variante [89ab] tout en autorisant explicitement l'UUID Nil (tout à zéro) et l'UUID Max (tout à un), et en normalisant les chiffres hexadécimaux majuscules en minuscules canoniques avant le stockage indexé sous forme de chaîne.

La norme RFC 9562 (mai 2024) a étendu la spécification UUID de cinq à huit versions et a officialisé deux constantes limites, rendant obsolètes les anciens modèles de validation encore intégrés dans de nombreuses bibliothèques de validation et passerelles d'API.

Pourquoi les anciennes expressions régulières RFC 4122 échouent sur les clés modernes

Les validateurs antérieurs à 2024 imposent généralement [1-5] sur le 13e chiffre hexadécimal et omettent les valeurs sentinelles, rejetant ainsi les clés valides UUIDv6, UUIDv7, UUIDv8, Nil et Max. Voici une expression régulière complète et insensible à la casse conforme à la RFC 9562 qui correspond à la syntaxe canonique 8-4-4-4-12 pour les versions v1 à v8 ainsi que Nil et 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})$

Lors de la validation d'entrées non fiables dans des environnements backend tels que Python, Ruby ou PCRE, ancrez la fin de la chaîne avec \z (ou \Z dans re.fullmatch en Python) plutôt qu'avec $, car $ correspond immédiatement avant un caractère de saut de ligne final \n et peut laisser passer des charges utiles injectées par saut de ligne à travers des vérifications de chaînes naïves.

Types `uuid` de base de données face aux schémas d'application stricts

Une source fréquente d'échecs d'ingestion en production est l'écart entre les analyseurs de bases de données permissifs et les validateurs stricts de schémas d'API :

  • Analyseurs hexadécimaux 128 bits permissifs (ex. uuid dans PostgreSQL) : PostgreSQL accepte n'importe quelle suite de 32 chiffres hexadécimaux (avec des tirets canoniques, des accolades {...} facultatives ou sans aucun tiret) quel que soit le quartet de version (0-f) ou le préfixe de variante (0xxx, 10xx, 110x, 111x). Les anciens GUID Microsoft COM (variante 110x, hexadécimal c ou d au 17e chiffre) ou les empreintes MD5 arbitraires de 128 bits stockées dans une colonne uuid passent les insertions SQL sans erreur.
  • Validateurs RFC 9562 stricts (OpenAPI, Zod, uuid en Rust, google/uuid en Go) : Les schémas d'API stricts vérifient la présence des tirets canoniques sur 36 caractères et imposent souvent la variante 10xx ainsi que les versions 1 à 8 (plus Nil/Max). Valider les exports SQL en masse avant de les rejouer contre des services REST ou gRPC stricts permet d'intercepter rapidement les lignes ayant une variante non conforme à la RFC.

Normalisation de la casse canonique

La section 4 de la RFC 9562 exige que les analyseurs acceptent les majuscules A-F en entrée tout en produisant des minuscules a-f en sortie. Les types de bases de données binaires natifs de 16 octets (UUID dans PostgreSQL, BINARY(16) dans MySQL) effacent automatiquement la casse des lettres, mais les systèmes stockant des UUID dans des colonnes VARCHAR(36), des clés Redis, des clés de partition DynamoDB ou des caches JSON traitent 550E8400-... et 550e8400-... comme des chaînes distinctes à moins qu'elles ne soient normalisées en minuscules lors de la validation.

Validateur d'UUID vs Analyseur d'UUID vs Générateur d'UUID : lequel choisir ?

Réponse rapide: Utilisez le Validateur d'UUID pour vérifier la syntaxe, contrôler la conformité à la RFC 9562, classer les versions sur des listes en masse et exporter des identifiants propres. Utilisez l'Analyseur et Décodeur d'UUID pour extraire les horodatages UTC intégrés et les champs de 128 bits d'un UUID spécifique, ou le Générateur d'UUID v4 pour créer de nouveaux identifiants aléatoires cryptographiques.

Choisissez l'utilitaire UUID Utiliome adapté selon que vous auditez des listes existantes, inspectez des champs de bits internes ou générez de nouvelles clés :

Capacité Validateur d'UUID (Cet outil) Analyseur et Décodeur d'UUID Générateur d'UUID v4
Objectif principal Valider des UUID uniques ou des lots multilignes et filtrer les entrées mal formées Décoder la disposition binaire 128 bits d'un UUID, l'ID de nœud et l'horodatage UTC intégré Générer en masse des identifiants UUIDv4 aléatoires cryptographiques (CSPRNG)
Traitement de listes en masse Oui — collez des listes ou importez des fichiers, consultez les diagnostics par ligne et exportez les lots valides Non — conçu pour l'inspection approfondie des champs de bits d'identifiants individuels Produit de nouveaux lots de clés v4 aléatoires ; ne valide pas les entrées externes
Couverture des versions Classe les versions v1 à v8, Nil (0000...) et Max (ffff...) Décode les structures de bits pour les versions v1 à v8, Nil et Max Génère exclusivement des UUIDv4 conformes à la RFC 9562 (utilisez le Générateur d'UUID v7, v6 et v1 pour des clés triées par date)
Extraction d'horodatage Identifie si une clé est basée sur le temps (v1, v6, v7) sans décoder les dates Extrait les dates UTC ISO-8601 exactes, les millisecondes Unix et les ticks grégoriens de 100 ns Non applicable (l'UUIDv4 contient 122 bits aléatoires et aucune donnée d'horodatage)

Flux de travail recommandés pour les développeurs

  • Nettoyage d'exports CSV, de journaux ou de charges utiles de migration : Collez votre liste ici pour séparer les identifiants RFC 9562 valides des chaînes corrompues, des ULID ou des anciens GUID non conformes à la RFC et exporter une liste propre en minuscules.
  • Vérification de la date de création d'une clé temporelle : Copiez n'importe quel identifiant v1, v6 ou v7 valide dans l'Analyseur et Décodeur d'UUID pour inspecter son horodatage de création UTC intégré, sa séquence d'horloge et ses champs binaires de 128 bits.
  • Génération de nouveaux identifiants : Utilisez le Générateur d'UUID v4 pour des jetons aléatoires imprévisibles, ou le Générateur d'UUID v7, v6 et v1 pour des clés primaires de base de données triables par ordre chronologique.
FAQ

FAQ et guide technique sur Validateur d'UUID

Tout ce qu'il faut savoir sur l'utilisation en ligne gratuite de validateur uuid.

Les UUID Nil (tout à zéro) et Max (tout à F) sont-ils valides selon la RFC 9562 ?

Oui. La section 5.9 de la RFC 9562 définit 00000000-0000-0000-0000-000000000000 comme l'UUID Nil, et la section 5.10 définit ffffffff-ffff-ffff-ffff-ffffffffffff comme l'UUID Max pour les valeurs sentinelles et les requêtes de plage de borne supérieure, même si leurs quartets de version et de variante se situent en dehors de [1-8] et [89ab].

Pourquoi un GUID Microsoft est-il accepté dans PostgreSQL mais échoue-t-il à la validation stricte RFC 9562 ?

Les anciens GUID Microsoft COM/DCOM peuvent porter la variante de rétrocompatibilité 110x (c ou d en hexadécimal au 17e chiffre) plutôt que la variante 10xx de la RFC 9562 (8, 9, a, b). Le type de colonne natif uuid de PostgreSQL accepte n'importe quelle valeur hexadécimale de 128 bits sans vérifier les bits de version ou de variante, tandis que les validateurs RFC 9562 stricts signalent les variantes autres que 10xx.

Les caractères hexadécimaux en majuscules rendent-ils un UUID invalide ?

Non. La section 4 de la RFC 9562 stipule que les analyseurs doivent accepter les majuscules A-F et les minuscules a-f sans distinction de casse lors de la lecture des UUID, tout en exigeant que les générateurs et les formateurs produisent de l'hexadécimal canonique en minuscules afin que les index de chaînes sensibles à la casse et les tables de hachage ne stockent pas de clés en double.

Pourquoi les anciennes expressions régulières de validation d'UUID rejettent-elles les UUID v7 et UUID v8 ?

Les modèles d'expressions régulières écrits pour la RFC 4122 (publiée en 2005) codent en dur [1-5] au 13e chiffre hexadécimal car seules les versions 1 à 5 existaient avant mai 2024, date à laquelle la RFC 9562 a standardisé la version grégorienne réordonnée v6, la version triée par temps Unix Epoch v7, la version personnalisée v8 et l'UUID Max composé uniquement de uns.

Les ULID, les GUID entre accolades ou les chaînes hexadécimales de 32 caractères sans tirets sont-ils des UUID canoniques valides ?

Pas sous forme textuelle canonique. Les ULID encodent 128 bits sous forme de 26 caractères Base32 de Crockford plutôt qu'en hexadécimal, tandis que les accolades {...}, les préfixes urn:uuid: et les chaînes de 32 caractères sans tirets sont des enveloppes de transport alternatives ; la syntaxe canonique des UUID de la RFC 9562 exige strictement 36 caractères formatés en chiffres hexadécimaux 8-4-4-4-12.