Wie teste ich eine gültige UUID / GUID?

Wie überprüfe ich, ob die Variable eine gültige UUID / GUID-Kennung enthält?

Ich bin derzeit nur daran interessiert, die Typen 1 und 4 zu validieren, aber es sollte keine Einschränkung Ihrer Antworten sein.

Derzeit entsprechen die UUIDs den Angaben in RFC4122. Ein oft vernachlässigter Rand Fall ist der NIL UUID, bemerkte hier . Der folgende reguläre Ausdruck berücksichtigt dies und gibt eine Übereinstimmung für eine NIL-UUID zurück. Unten finden Sie eine UUID, die nur Nicht-NIL-UUIDs akzeptiert. Beide Lösungen gelten für die Versionen 1 bis 5 (siehe das erste Zeichen des dritten Blocks).

Um eine UUID zu validieren ...

/^[0-9a-f]{8}-[0-9a-f]{4}-[0-5][0-9a-f]{3}-[089ab][0-9a-f]{3}-[0-9a-f]{12}$/i

... stellt sicher, dass Sie eine kanonisch formatierte UUID haben, die Version 1 bis 5 ist und die entsprechende Variante gemäß RFC4122 ist.

HINWEIS: Klammern {und }sind nicht kanonisch. Sie sind ein Artefakt einiger Systeme und Verwendungen.

Es ist einfach, den obigen regulären Ausdruck zu ändern, um die Anforderungen der ursprünglichen Frage zu erfüllen.

TIPP: Regex-Gruppe / Captures

So vermeiden Sie eine Übereinstimmung mit der NIL-UUID:

/^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i

Regex zur Rettung

/^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/.test('01234567-9ABC-DEF0-1234-56789ABCDEF0');

oder mit Klammern

/^\{?[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{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

Wenn Sie Node.js für die Entwicklung verwenden, wird empfohlen, ein Paket namens Validator zu verwenden. Es enthält alle regulären Ausdrücke, die zum Validieren verschiedener Versionen von UUIDs erforderlich sind, und Sie erhalten verschiedene andere Funktionen zur Validierung.

Hier ist der npm-Link: Validator

var a = 'd3aa88e2-c754-41e0-8ba6-4198a34aa0a2'
v.isUUID(a)
true
v.isUUID('abc')
false
v.isNull(a)
false

Neben der Antwort von Gambol , die in fast allen Fällen die Aufgabe erfüllt , wurden alle bisher gegebenen Antworten übersehen, sodass die gruppierte Formatierung (8-4-4-4-12) nicht erforderlich ist, um GUIDs in Text zu codieren . Es wird extrem oft verwendet, aber natürlich kann auch eine einfache Kette mit 32 hexadezimalen Ziffern gültig sein. ^[1] Regex _Enh :

/^[0-9a-f]{8}-?[0-9a-f]{4}-?[1-5][0-9a-f]{3}-?[89ab][0-9a-f]{3}-?[0-9a-f]{12}$/i

^[1] Die Frage ist , über Check ing Variable s, so dass wir die benutzerunfreundlich Form als auch enthalten sollen.

• Warum enthält eine .NET-GUID Bindestriche? - Stapelüberlauf plus Akzeptierte Antwort
• Testen und validieren Sie eine GUID (guid.us)
• Guid.ToString-Methode (Zeichenfolge) (MSDN)

Alle bisher veröffentlichten typspezifischen regulären Ausdrücke schlagen in der Null-UUID "Typ 0" fehl, die in 4.1.7 des RFC wie folgt definiert ist:

Die Null-UUID ist eine spezielle Form der UUID, bei der alle 128 Bits auf Null gesetzt sind: 00000000-0000-0000-0000-000000000000

So ändern Sie Wolfs Antwort:

/^[0-9a-f]{8}-?[0-9a-f]{4}-?[0-5][0-9a-f]{3}-?[089ab][0-9a-f]{3}-?[0-9a-f]{12}$/i

Oder um einen "Typ 0" ohne alle Nullen richtig auszuschließen, haben wir Folgendes (danke an Luke):

/^(?:[0-9a-f]{8}-?[0-9a-f]{4}-?[1-5][0-9a-f]{3}-?[89ab][0-9a‌​-f]{3}-?[0-9a-f]{12}‌​|00000000-0000-0000-‌​0000-000000000000)$/‌​i

danke an @usertatha mit einigen modifikationen

function isUUID ( uuid ) {
    let s = "" + uuid;

    s = s.match('^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$');
    if (s === null) {
      return false;
    }
    return true;
}

Ich denke, Gambols Antwort ist fast perfekt, aber sie interpretiert den RFC 4122 § 4.1.1 falsch . Variantenabschnitt etwas.

Es deckt UUIDs der Variante 1 (10xx = 8..b) ab, jedoch nicht die Varianten der Varianten 0 (0xxx = 0..7) und 2 (110x = c..d), die der Abwärtskompatibilität vorbehalten sind. Sie sind also technisch gültige UUIDs. Variante-4 (111x = e..f) ist in der Tat für die zukünftige Verwendung reserviert, daher sind sie derzeit nicht gültig.

Außerdem ist der Typ 0 nicht gültig. Diese "Ziffer" darf nur 0 sein, wenn es sich um eine NIL-UUID handelt (wie in Evans Antwort erwähnt ).

Daher denke ich, dass der genaueste reguläre Ausdruck, der der aktuellen RFC 4122-Spezifikation entspricht, (einschließlich Bindestriche) lautet:

/^([0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[0-9a-d][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000)$/i
                            ^                ^^^^^^
                    (0 type is not valid)  (only e..f variant digit is invalid currently)

Verwenden Sie die Methode .match (), um zu überprüfen, ob String eine UUID ist.

public boolean isUUID(String s){
    return s.match("^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$");
}

Eine leicht modifizierte Version der obigen Antworten, die präziser geschrieben wurde. Dadurch wird jede GUID mit Bindestrichen überprüft (kann jedoch leicht geändert werden, um Bindestriche optional zu machen). Dies unterstützt auch Groß- und Kleinbuchstaben, die unabhängig von der Spezifikation zur Konvention geworden sind:

/^([0-9a-fA-F]{8})-(([0-9a-fA-F]{4}\-){3})([0-9a-fA-F]{12})$/i

Der Schlüssel hier ist der sich wiederholende Teil unten

(([0-9a-fA-F]{4}\-){3})

Was einfach die 4 Zeichenmuster 3 Mal wiederholt

Eine gute Möglichkeit, dies in Node zu tun, ist die Verwendung des ajvPakets ( https://github.com/epoberezkin/ajv ).

const Ajv = require('ajv');
const ajv = new Ajv({ allErrors: true, useDefault: true, verbose: true });
const uuidSchema = { type: 'string', format: 'uuid' };
ajv.validate(uuidSchema, 'bogus'); // returns false
ajv.validate(uuidSchema, 'd42a8273-a4fe-4eb2-b4ee-c1fc57eb9865'); // returns true with v4 GUID
ajv.validate(uuidSchema, '892717ce-3bd8-11ea-b77f-2e728ce88125'); // returns true with a v1 GUID

Ich denke, ein besserer Weg ist die Verwendung der statischen Methode von String, um diese regulären Ausdrücke zu vermeiden.

    id = UUID.randomUUID();
    UUID uuid = UUID.fromString(id.toString());
    Assert.assertEquals(id.toString(), uuid.toString());

Andererseits

   UUID uuidFalse = UUID.fromString("x");

löst java.lang.IllegalArgumentException aus: Ungültige UUID-Zeichenfolge: x