Поиск UUID в тексте с помощью регулярных выражений

Я ищу UUID в блоках текста с помощью регулярных выражений. В настоящее время я полагаюсь на предположение, что все UUID будут следовать шаблонам из 8-4-4-4-12 шестнадцатеричных цифр.

Кто-нибудь может вспомнить случай использования, когда это предположение было бы неверным и заставило бы меня пропустить некоторые UUID?

Я согласен, что по определению ваше регулярное выражение не пропускает ни одного UUID. Однако может быть полезно отметить, что если вы ищете специально для глобальных уникальных идентификаторов (GUID) от Microsoft, есть пять эквивалентных строковых представлений для 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}}" 

Регулярное выражение для 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 может иметь заглавные буквы. Так что вам нужно либо toLowerCase () строки, либо использовать:

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

Только что прокомментировал это, но не достаточно репутации :)

UUID версии 4 имеют форму xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx, где x - любая шестнадцатеричная цифра, а y - одно из 8, 9, A или B. Например, f47ac10b-58cc-4372-a567-0e02b2c3d479.

источник: http://en.wikipedia.org/wiki/Uuid#Definition

Следовательно, это технически более правильно:

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

Если вы хотите проверить или проверить конкретную версию UUID , вот соответствующие регулярные выражения.

Обратите внимание, что единственным отличием является номер версии , который объясняется в 4.1.3. Versionглаве UUID 4122 RFC .

Номер версии является первым символом третьей группы [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

Регулярное выражение Gajus отклоняет UUID V1-3 и 5, даже если они действительны.

[\w]{8}(-[\w]{4}){3}-[\w]{12} работал для меня в большинстве случаев.

Или если вы хотите быть действительно конкретным [\w]{8}-[\w]{4}-[\w]{4}-[\w]{4}-[\w]{12}.

В python re, вы можете перейти от цифр до букв верхнего регистра. Так..

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

Это делает простейшее регулярное выражение Python UUID:

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

Я оставлю это в качестве упражнения для читателя, чтобы использовать timeit для сравнения их производительности.

Наслаждаться. Держите это Pythonic ™!

ПРИМЕЧАНИЕ. Эти промежутки также будут совпадать, :;<=>?@'поэтому, если вы подозреваете, что это может дать вам ложные срабатывания, не используйте ярлык. (Спасибо, Оливер Обер, за то, что указал на это в комментариях.)

По определению UUID - это 32 шестнадцатеричные цифры, разделенные на 5 групп дефисами, как вы уже описали. Вы не должны пропустить ни одного со своим регулярным выражением лица.

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

Итак, я думаю, что Ричард Броноски на самом деле имеет лучший ответ на сегодняшний день, но я думаю, что вы можете сделать немного, чтобы сделать его несколько проще (или, по крайней мере, более кратким):

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

Вариант для 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];

Для UUID, сгенерированного в OS X с uuidgen, шаблон регулярного выражения

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

Проверить с помощью

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;

Кстати, разрешение только 4 на одну из позиций действительно только для UUIDv4. Но v4 не единственная версия UUID, которая существует. Я встречал v1 в своей практике.

Если вы используете Posix Regex ( grep -E, MySQL и т. Д.), Это может быть проще для чтения и запоминания:

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

Для Баш:

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

Например:

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