Búsqueda de UUID en texto con expresiones regulares

Estoy buscando UUID en bloques de texto usando una expresión regular. Actualmente confío en el supuesto de que todos los UUID seguirán un patrón de 8-4-4-4-12 dígitos hexadecimales.

¿Alguien puede pensar en un caso de uso donde esta suposición no sea válida y me haga perder algunos UUID?

Estoy de acuerdo en que, por definición, su expresión regular no pierde ningún UUID. Sin embargo, puede ser útil tener en cuenta que si está buscando especialmente los identificadores únicos globales (GUID) de Microsoft, hay cinco representaciones de cadena equivalentes para 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}}" 

La expresión regular para uuid es:

\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 puede tener mayúsculas. Por lo tanto, necesitará toLowerCase () la cadena o 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}

Hubiera comentado esto pero no suficiente representante :)

Los UUID de la versión 4 tienen la forma xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx donde x es cualquier dígito hexadecimal e y es uno de 8, 9, A o B. por ejemplo, f47ac10b-58cc-4372-a567-0e02b2c3d479.

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

Por lo tanto, esto es técnicamente más correcto:

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

Si desea verificar o validar una versión específica de UUID , aquí están las expresiones regulares correspondientes.

Tenga en cuenta que la única diferencia es el número de versión , que se explica en el 4.1.3. Versioncapítulo de UUID 4122 RFC .

El número de versión es el primer carácter del tercer 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

La expresión regular de Gajus rechaza UUID V1-3 y 5, aunque sean válidos.

[\w]{8}(-[\w]{4}){3}-[\w]{12} me ha funcionado en la mayoría de los casos.

O si quieres ser realmente específico [\w]{8}-[\w]{4}-[\w]{4}-[\w]{4}-[\w]{12}.

En python re, puede abarcar desde números numéricos a mayúsculas alfa. Entonces..

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

Eso hace que la expresión regular UUID de Python más simple:

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

Lo dejaré como un ejercicio para que el lector use timeit para comparar el rendimiento de estos.

Disfrutar. ¡Mantenlo Pythonic ™!

NOTA: Esos tramos también coincidirán :;<=>?@', por lo tanto, si sospecha que podría darle falsos positivos, no tome el atajo. (Gracias Oliver Aubert por señalar eso en los comentarios).

Por definición, un UUID tiene 32 dígitos hexadecimales, separados en 5 grupos por guiones, tal como lo ha descrito. No debes perderte ninguno con tu expresión regular.

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

Entonces, creo que Richard Bronosky en realidad tiene la mejor respuesta hasta la fecha, pero creo que puede hacer un poco para que sea algo más simple (o al menos terser):

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 generado en OS X con uuidgen, el patrón regex es

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

Verificar con

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;

Por cierto, permitir solo 4 en una de las posiciones solo es válido para UUIDv4. Pero v4 no es la única versión de UUID que existe. También he conocido v1 en mi práctica.

Si usa Posix regex ( grep -E, MySQL, etc.), esto puede ser más fácil de leer y recordar:

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

Para 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 ejemplo:

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