Procurando UUIDs em texto com regex

Estou procurando por UUIDs em blocos de texto usando um regex. Atualmente, estou confiando na suposição de que todos os UUIDs seguirão um padrão de 8-4-4-4-12 dígitos hexadecimais.

Alguém pode pensar em um caso de uso em que essa suposição seria inválida e me faria perder alguns UUIDs?

Concordo que, por definição, seu regex não perde nenhum UUID. No entanto, pode ser útil observar que, se você estiver pesquisando especialmente os GUIDs (Globally Unique Identifiers) da Microsoft, há cinco representações de seqüência de caracteres equivalentes para um 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}}" 

O regex para uuid é:

\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 pode ter maiúsculas. Então você precisará toLowerCase () a string ou usará:

[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}

Teria acabado de comentar isso, mas não o suficiente rep :)

Os UUIDs da versão 4 têm o formato xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx, em que x é qualquer dígito hexadecimal e y é um de 8, 9, A ou B. por exemplo, f47ac10b-58cc-4372-a567-0e02b2c3d479.

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

Portanto, isso é tecnicamente mais correto:

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

Se você deseja verificar ou validar uma versão UUID específica , aqui estão as regexes correspondentes.

Observe que a única diferença é o número da versão , explicado no 4.1.3. Versioncapítulo do RFC UUID 4122 .

O número da versão é o primeiro caractere do terceiro grupo [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

O regexp de Gajus rejeita UUID V1-3 e 5, mesmo que eles sejam válidos.

[\w]{8}(-[\w]{4}){3}-[\w]{12} funcionou para mim na maioria dos casos.

Ou se você quiser ser realmente específico [\w]{8}-[\w]{4}-[\w]{4}-[\w]{4}-[\w]{12}.

No python re, você pode abranger de alfa numérico a maiúsculo. Assim..

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']

Isso torna a regex UUID do Python mais simples:

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

Vou deixar como um exercício para o leitor usar o timeit para comparar o desempenho deles.

Aproveitar. Mantenha-o Pythonic ™!

OBSERVAÇÃO: esses intervalos também corresponderão :;<=>?@'; se você suspeitar que isso possa dar falsos positivos, não use o atalho. (Obrigado Oliver Aubert por apontar isso nos comentários.)

Por definição, um UUID tem 32 dígitos hexadecimais, separados em 5 grupos por hífens, exatamente como você descreveu. Você não deve perder nada com sua expressão regular.

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

Então, acho que Richard Bronosky realmente tem a melhor resposta até o momento, mas acho que você pode fazer um pouco para torná-lo um pouco mais simples (ou pelo menos terso):

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

Variante para 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];

Para UUID gerado no OS X com uuidgen, o padrão regex é

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

Verifique com

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, permitir apenas 4 em uma das posições é válido apenas para UUIDv4. Mas a v4 não é a única versão UUID que existe. Também conheci a v1 na minha prática.

Se você estiver usando o Regex Posix ( grep -EMySQL, etc.), pode ser mais fácil ler e lembrar:

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

Para o 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}"

Por exemplo:

$> 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