Suche nach UUIDs in Text mit Regex

Ich suche nach UUIDs in Textblöcken mit einem regulären Ausdruck. Derzeit gehe ich davon aus, dass alle UUIDs einem Muster von 8-4-4-4-12 hexadezimalen Ziffern folgen.

Kann sich jemand einen Anwendungsfall vorstellen, bei dem diese Annahme ungültig wäre und dazu führen würde, dass ich einige UUIDs verpasse?

Ich bin damit einverstanden, dass Ihre Regex per Definition keine UUID übersieht. Es kann jedoch hilfreich sein zu beachten, dass es bei der Suche nach GUIDs (Global Unique Identifiers) von Microsoft fünf äquivalente Zeichenfolgendarstellungen für eine GUID gibt:

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

Der reguläre Ausdruck für uuid lautet:

\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 kann Großbuchstaben haben. Sie müssen also entweder den String toLowerCase () verwenden oder Folgendes verwenden:

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

Hätte das nur kommentiert aber nicht genug rep :)

UUIDs der Version 4 haben die Form xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx, wobei x eine beliebige hexadezimale Ziffer und y eine von 8, 9, A oder B ist, z. B. f47ac10b-58cc-4372-a567-0e02b2c3d479.

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

Daher ist dies technisch korrekter:

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

Wenn Sie eine bestimmte UUID-Version überprüfen oder validieren möchten , finden Sie hier die entsprechenden regulären Ausdrücke.

Beachten Sie, dass der einzige Unterschied die Versionsnummer ist , die im 4.1.3. VersionKapitel von UUID 4122 RFC erläutert wird .

Die Versionsnummer ist das erste Zeichen der dritten Gruppe [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 'regulärer Ausdruck lehnt UUID V1-3 und 5 ab, obwohl sie gültig sind.

[\w]{8}(-[\w]{4}){3}-[\w]{12} hat in den meisten Fällen für mich gearbeitet.

Oder wenn Sie wirklich spezifisch sein wollen [\w]{8}-[\w]{4}-[\w]{4}-[\w]{4}-[\w]{12}.

In Python Re können Sie von numerischen bis zu Großbuchstaben Alpha wechseln. So..

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

Das macht den einfachsten Python-UUID-Regex:

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

Ich überlasse es dem Leser als Übung, timeit zu verwenden, um die Leistung dieser zu vergleichen.

Genießen. Behalte es Pythonic ™!

HINWEIS: Diese Bereiche stimmen auch überein :;<=>?@'. Wenn Sie den Verdacht haben, dass dies zu falsch positiven Ergebnissen führen könnte, verwenden Sie nicht die Verknüpfung. (Vielen Dank an Oliver Aubert, der in den Kommentaren darauf hingewiesen hat.)

Per Definition besteht eine UUID aus 32 hexadezimalen Ziffern, die wie beschrieben in 5 Gruppen durch Bindestriche getrennt sind. Sie sollten keine mit Ihrem regulären Ausdruck verpassen.

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

Ich denke, Richard Bronosky hat tatsächlich die bisher beste Antwort, aber ich denke, Sie können ein wenig tun, um es etwas einfacher (oder zumindest kürzer) zu machen:

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

Variante für 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];

Für UUID, die unter OS X mit generiert wurde uuidgen, lautet das Regex-Muster

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

Überprüfen Sie mit

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;

Übrigens, nur 4 auf einer der Positionen zuzulassen, gilt nur für UUIDv4. V4 ist jedoch nicht die einzige existierende UUID-Version. Ich habe v1 auch in meiner Praxis getroffen.

Wenn Sie Posix Regex ( grep -E, MySQL usw.) verwenden, ist dies möglicherweise einfacher zu lesen und zu merken:

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

Für 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}"

Beispielsweise:

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