Qu'est-ce qu'un GUID ?

Un GUID est un identifiant unique de 128 bits souvent utilisé pour étiqueter des ressources comme des utilisateurs, des sessions ou des enregistrements. Il apparaît sous la forme d'une chaîne dans ce format :

xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx

Où chaque x est un chiffre hexadécimal (0-9, a-f ou A-F). Bien que les GUID et UUID soient fonctionnellement similaires, les GUID sont plus courants dans les systèmes Microsoft.

Pattern regex pour GUID en Python

Voici un pattern regex qui valide avec précision un GUID standard :

^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-5][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}$

Ce pattern garantit :

• 8 chiffres au début

• Suivis de trois groupes de 4 chiffres (séparés par des tirets)

• Se termine par 12 chiffres hexadécimaux

Améliorer le regex pour une validation GUID plus stricte

Le pattern original \w{8}-\w{4}-\w{4}-\w{4}-\w{12} vérifie la structure globale correcte, mais il est un peu trop permissif : il correspond à tout caractère "mot" (lettres, chiffres et underscores), pas seulement aux chiffres hexadécimaux. Des caractères non hexadécimaux (comme les underscores) passeraient incorrectement comme valides.

Pour resserrer la validation et s'assurer que chaque segment ne correspond qu'aux caractères hexadécimaux (0-9, a-f, A-F), vous pouvez affiner le pattern ainsi :

^[0-9a-fA-F]{8}-([0-9a-fA-F]{4}-){3}[0-9a-fA-F]{12}$

Cette version garantit :

• Chaque groupe ne contient que des chiffres hexadécimaux valides.

• Les longueurs exactes et les placements des tirets sont imposés.

• Les caractères supplémentaires ou invalides seront correctement rejetés.

Pour une validation encore plus stricte (comme la validation des bits de version ou de variante spécifiques du GUID), vous pouvez aller plus loin :

^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-5][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}$

Exemple Python pour valider un GUID

import re
def is_valid_guid(guid):
pattern = re.compile(
r'^[0-9a-fA-F]{8}-'
r'[0-9a-fA-F]{4}-'
r'[1-5][0-9a-fA-F]{3}-'
r'[89abAB][0-9a-fA-F]{3}-'
r'[0-9a-fA-F]{12}$'
)
return bool(pattern.fullmatch(guid))
GUID de test
test_guids = [
"123e4567-e89b-12d3-a456-426614174000",
"00112233-4455-6677-8899-aabbccddeeff",
"invalid-guid-format"
]
for g in test_guids:
print(f"{g} -> {is_valid_guid(g)}")

Faut-il utiliser \w ou [a-f0-9] dans les patterns regex GUID ?

Bien qu'il soit tentant d'utiliser \w comme raccourci, ce caractère est trop générique pour la validation GUID.

La différence fondamentale

• \w correspond aux lettres majuscules et minuscules (A-Z, a-z), aux chiffres (0-9) et à l'underscore (_).

• [a-f0-9] restreint spécifiquement la correspondance aux chiffres hexadécimaux minuscules, ce qui est exactement ce que les GUID standard utilisent.

Pourquoi la précision est importante

Le pattern permissif \w{8}-\w{4}-\w{4}-\w{4}-\w{12} accepterait les underscores et toutes les lettres de l'alphabet. En revanche :

^[a-f0-9]{8}-([a-f0-9]{4}-){3}[a-f0-9]{12}$

Ce pattern impose uniquement les chiffres hexadécimaux minuscules (a-f, 0-9) à chaque segment.

Quand utiliser lequel

• Choisissez [a-f0-9] pour une validation GUID stricte en minuscules uniquement.

• Si vous attendez des hexadécimaux en majuscules dans les GUID, utilisez [a-fA-F0-9].

Pourquoi \w ne suffit pas

Utiliser \w revient à être trop permissif. Par exemple, une chaîne comme ABCD_EF9-1234-5678-9abc-def012345678 correspondrait (incorrectement) à votre regex, même si les underscores ne sont pas valides dans les GUID standard. Le pattern plus restrictif fourni ci-dessus limite explicitement chaque caractère aux seuls chiffres hexadécimaux valides (0-9, a-f, A-F).

Cas d'utilisation

• Identifiants d'enregistrements de base de données : Utilisez des GUID comme clés primaires pour les systèmes distribués.

• Tokens d'authentification : Validez les GUID transmis via des en-têtes API ou des chaînes de requête.

• Synchronisation des données : Faites correspondre les GUID dans le stockage local et distant pour assurer la cohérence.

• Outils de débogage : Utilisez-le avec le Validateur regex Python d'adresses IP pour surveiller les identifiants réseau.

Conseils avancés

• Assainissez toujours les entrées GUID, surtout lorsqu'elles proviennent de sources côté client.

• Supprimez les espaces de début et de fin avant la validation.

• Associez-le au Validateur regex Python de dates lorsque vous travaillez avec des identifiants horodatés.

• Utilisez des GUID en minuscules dans les systèmes où la casse n'a pas d'importance, pour maintenir la cohérence.