Recherche d'UUID dans le texte avec regex

Je recherche des UUID dans des blocs de texte à l'aide d'une expression régulière. Actuellement, je me fie à l'hypothèse que tous les UUID suivront un modèle de 8-4-4-4-12 chiffres hexadécimaux.

Quelqu'un peut-il penser à un cas d'utilisation où cette hypothèse serait invalide et me ferait manquer certains UUID?

Je suis d'accord que par définition, votre regex ne manque aucun UUID. Cependant, il peut être utile de noter que si vous recherchez en particulier les identificateurs globaux uniques (GUID) de Microsoft, il existe cinq représentations de chaînes équivalentes pour un GUID:

"ca761232ed4211cebacd00aa0057b223" 

"CA761232-ED42-11CE-BACD-00AA0057B223" 

"{CA761232-ED42-11CE-BACD-00AA0057B223}" 

"(CA761232-ED42-11CE-BACD-00AA0057B223)" 

"{0xCA761232, 0xED42, 0x11CE, {0xBA, 0xCD, 0x00, 0xAA, 0x00, 0x57, 0xB2, 0x23}}" 

Le regex pour uuid est:

\b[0-9a-f]{8}\b-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-\b[0-9a-f]{12}\b

@ivelin: UUID peut avoir des majuscules. Vous devrez donc soit toLowerCase () la chaîne ou utiliser:

[a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12}

Aurait juste commenté cela mais pas assez de représentants :)

Les UUID de la version 4 ont la forme xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx où x est un chiffre hexadécimal et y est l'un des 8, 9, A ou B. Par exemple f47ac10b-58cc-4372-a567-0e02b2c3d479.

la source: http://en.wikipedia.org/wiki/Uuid#Definition

C'est donc techniquement plus correct:

/[a-f0-9]{8}-[a-f0-9]{4}-4[a-f0-9]{3}-[89aAbB][a-f0-9]{3}-[a-f0-9]{12}/

Si vous souhaitez vérifier ou valider une version UUID spécifique , voici les expressions rationnelles correspondantes.

Notez que la seule différence est le numéro de version , qui est expliqué dans le 4.1.3. Versionchapitre de l' UUID 4122 RFC .

Le numéro de version est le premier caractère du troisième groupe [VERSION_NUMBER][0-9A-F]{3}::

• UUID v1:

  /^[0-9A-F]{8}-[0-9A-F]{4}-[1][0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}$/i

• UUID v2:

  /^[0-9A-F]{8}-[0-9A-F]{4}-[2][0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}$/i

• UUID v3:

  /^[0-9A-F]{8}-[0-9A-F]{4}-[3][0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}$/i

• UUID v4:

  /^[0-9A-F]{8}-[0-9A-F]{4}-[4][0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}$/i

• UUID v5:

  /^[0-9A-F]{8}-[0-9A-F]{4}-[5][0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}$/i

/^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89AB][0-9a-f]{3}-[0-9a-f]{12}$/i

L'expression régulière de Gajus rejette les UUID V1-3 et 5, même si elles sont valides.

[\w]{8}(-[\w]{4}){3}-[\w]{12} a travaillé pour moi dans la plupart des cas.

Ou si vous voulez être vraiment précis [\w]{8}-[\w]{4}-[\w]{4}-[\w]{4}-[\w]{12}.

Dans python re, vous pouvez s'étendre du numérique au alpha majuscule. Alors..

import re
test = "01234ABCDEFGHIJKabcdefghijk01234abcdefghijkABCDEFGHIJK"
re.compile(r'[0-f]+').findall(test) # Bad: matches all uppercase alpha chars
## ['01234ABCDEFGHIJKabcdef', '01234abcdef', 'ABCDEFGHIJK']
re.compile(r'[0-F]+').findall(test) # Partial: does not match lowercase hex chars
## ['01234ABCDEF', '01234', 'ABCDEF']
re.compile(r'[0-F]+', re.I).findall(test) # Good
## ['01234ABCDEF', 'abcdef', '01234abcdef', 'ABCDEF']
re.compile(r'[0-f]+', re.I).findall(test) # Good
## ['01234ABCDEF', 'abcdef', '01234abcdef', 'ABCDEF']
re.compile(r'[0-Fa-f]+').findall(test) # Good (with uppercase-only magic)
## ['01234ABCDEF', 'abcdef', '01234abcdef', 'ABCDEF']
re.compile(r'[0-9a-fA-F]+').findall(test) # Good (with no magic)
## ['01234ABCDEF', 'abcdef', '01234abcdef', 'ABCDEF']

Cela fait l'expression rationnelle UUID Python la plus simple:

re_uuid = re.compile("[0-F]{8}-([0-F]{4}-){3}[0-F]{12}", re.I)

Je laisserai au lecteur le soin d'utiliser timeit pour comparer les performances de ceux-ci.

Prendre plaisir. Gardez-le Pythonic ™!

REMARQUE: ces plages correspondent également :;<=>?@'. Si vous pensez que cela pourrait vous donner de faux positifs, ne prenez pas le raccourci. (Merci Oliver Aubert de l'avoir signalé dans les commentaires.)

Par définition, un UUID est composé de 32 chiffres hexadécimaux, séparés en 5 groupes par des tirets, comme vous l'avez décrit. Vous ne devriez pas en manquer avec votre expression régulière.

http://en.wikipedia.org/wiki/Uuid#Definition

Donc, je pense que Richard Bronosky a en fait la meilleure réponse à ce jour, mais je pense que vous pouvez faire un peu pour le rendre un peu plus simple (ou au moins terser):

re_uuid = re.compile(r'[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}', re.I)

Variante pour C ++:

#include <regex>  // Required include

...

// Source string    
std::wstring srcStr = L"String with GIUD: {4d36e96e-e325-11ce-bfc1-08002be10318} any text";

// Regex and match
std::wsmatch match;
std::wregex rx(L"(\\{[A-F0-9]{8}-[A-F0-9]{4}-[A-F0-9]{4}-[A-F0-9]{4}-[A-F0-9]{12}\\})", std::regex_constants::icase);

// Search
std::regex_search(srcStr, match, rx);

// Result
std::wstring strGUID       = match[1];

Pour les UUID générés sur OS X avec uuidgen, le modèle d'expression régulière est

[A-F0-9]{8}-[A-F0-9]{4}-4[A-F0-9]{3}-[89AB][A-F0-9]{3}-[A-F0-9]{12}

Vérifiez avec

uuidgen | grep -E "[A-F0-9]{8}-[A-F0-9]{4}-4[A-F0-9]{3}-[89AB][A-F0-9]{3}-[A-F0-9]{12}"

$UUID_RE = join '-', map { "[0-9a-f]{$_}" } 8, 4, 4, 4, 12;

BTW, autorisant seulement 4 sur l'une des positions n'est valable que pour UUIDv4. Mais la v4 n'est pas la seule version UUID qui existe. J'ai également rencontré la v1 dans ma pratique.

Si vous utilisez l'expression rationnelle Posix ( grep -E, MySQL, etc.), cela peut être plus facile à lire et à mémoriser:

[[:xdigit:]]{8}(-[[:xdigit:]]{4}){3}-[[:xdigit:]]{12}

Pour bash:

grep -E "[a-f0-9]{8}-[a-f0-9]{4}-4[a-f0-9]{3}-[89aAbB][a-f0-9]{3}-[a-f0-9]{12}"

Par exemple:

$> echo "f2575e6a-9bce-49e7-ae7c-bff6b555bda4" | grep -E "[a-f0-9]{8}-[a-f0-9]{4}-4[a-f0-9]{3}-[89aAbB][a-f0-9]{3}-[a-f0-9]{12}"
f2575e6a-9bce-49e7-ae7c-bff6b555bda4