Normal ifade ile metinde UUID'leri arama

Normal ifadeler kullanarak metin bloklarında UUID'leri arıyorum. Şu anda tüm UUID'lerin 8-4-4-4-12 onaltılık basamaklı bir patttern izleyeceği varsayımına güveniyorum.

Herkes bu varsayımın geçersiz olacağı ve bazı UUID'leri kaçırmamı sağlayacak bir kullanım durumu düşünebilir mi?

Tanım gereği normal ifadenizin herhangi bir UUID'yi kaçırmamasını kabul ediyorum. Bununla birlikte, özellikle Microsoft'un Global Benzersiz Tanımlayıcılarını (GUID'ler) arıyorsanız, bir GUID için beş eşdeğer dize temsili olduğunu unutmayın:

"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 için normal ifade:

\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'nin büyük harfleri olabilir. Yani ya dizeyi toLowerCase () yapmanız veya kullanmanız gerekecek:

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

Sadece bu ama yeterli temsilcisi yorum olurdu :)

Sürüm 4 UUID'ler, xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx biçimindedir; burada x, herhangi bir onaltılık basamaktır ve y, 8, 9, A veya B'den biridir. Örn. F47ac10b-58cc-4372-a567-0e02b2c3d479.

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

Bu nedenle, bu teknik olarak daha doğrudur:

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

Belirli bir UUID sürümünü kontrol etmek veya doğrulamak istiyorsanız , karşılık gelen normal ifadeler aşağıda verilmiştir.

Tek farkın, UUID 4122 RFC4.1.3. Version bölümünde açıklanan sürüm numarası olduğuna dikkat edin .

Sürüm numarası üçüncü grubun ilk karakteridir [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'un normal ifadesi, geçerli olsalar bile UUID V1-3 ve 5'i reddediyor.

[\w]{8}(-[\w]{4}){3}-[\w]{12} çoğu durumda benim için çalıştı.

Ya da gerçekten spesifik olmak istiyorsanız [\w]{8}-[\w]{4}-[\w]{4}-[\w]{4}-[\w]{12}.

Python re'de, rakamsaldan büyük harfli alfa'ya yayılabilir. Yani..

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

Bu en basit Python UUID normal ifadesini yapar:

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

Bunların performansını karşılaştırmak için timeit kullanmak için okuyucuya bir egzersiz olarak bırakacağım.

Zevk almak. Pythonic ™ 'i saklayın!

NOT: Bu açıklıklar da eşleşecektir :;<=>?@', size yanlış pozitifler verebileceğinden şüpheleniyorsanız, kısayolu almayın. (Bunu yorumlarda belirttiğiniz için Oliver Aubert'e teşekkür ederiz.)

Tanım olarak, bir UUID, tanımladığınız gibi 5 grupta tirelerle ayrılmış 32 onaltılık basamaktır. Normal ifadenizle hiçbirini kaçırmamalısınız.

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

Yani, Richard Bronosky'nin aslında bugüne kadar en iyi cevabı olduğunu düşünüyorum, ancak bence bunu biraz daha basit (veya en azından terser) yapmak için biraz yapabilirsiniz:

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

C ++ için varyant:

#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];

OS X ile birlikte oluşturulan UUID uuidgeniçin normal ifade deseni

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

İle doğrulayın

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, konumlardan birinde yalnızca 4'e izin verilmesi yalnızca UUIDv4 için geçerlidir. Ancak v4 varolan tek UUID sürümü değildir. Uygulamada da v1 ile tanıştım.

Posix normal ifadesi ( grep -E, MySQL, vb.) Kullanıyorsanız, bunu okumak ve hatırlamak daha kolay olabilir:

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

Bash için:

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

Örneğin:

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