Пошук UUID в тексті з регулярним виразом

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

Чи може хтось придумати випадок використання, коли це припущення було б недійсним і змусило б я пропустити деякі UUID?

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

Це робить найпростіший регулярний вираз UUID Python:

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;

BTW, що допускає лише 4 на одній з позицій, справедливий лише для UUIDv4. Але v4 - не єдина версія UUID, яка існує. Я також зустрічав v1 у своїй практиці.

Якщо використовується Pogex 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