Wie teste ich eine gültige UUID / GUID?

270

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.

javascript regex validation uuid guid Marek Sebera
quelle
im String-Format, nicht hex, nicht bin, oder ich weiß nicht, wonach Sie fragen
Marek Sebera
^ (\ {) {0,1} [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} (\}) {0,1} $
Brandon Moretz
Wenn Sie Variablen mit einer Kette von 32 aufeinanderfolgenden Hex-Ziffern (ohne Gruppierung) nicht ausschließen können, schauen Sie sich meine Antwort an
Wolf

Antworten:

413

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
Gambol
quelle
9
+1 Für die Erwähnung der Internet Engineering Task Force (IETF)
mate64
1
Ich denke, [1-5] [0-9a-f] {3} ist falsch. Ich habe eine gültige UUID mit "b06a" in diesem Teil, und dies ist für mich fehlgeschlagen.
Felipe Brahm
1
@FelipeBrahm, [1-5] ist laut RFC richtig, dass 4 Bits die Version angeben und es nur 5 Versionen gibt.
Rvignacio
749d0000-0194-1005-2e05-08d61613bf2f nicht für mich in der Geige
raubt
1
Aus Neugier (warum) wäre das Folgende nicht auch gültig: [0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}
tjeerdnet
58

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}‌​\}?$/
Ryanb
quelle
3
oder wenn Sie Klammern haben könnten: / ^ \ {? [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');
Ryanb
Das ist nicht ganz richtig. es fehlt, dass [1-5] (Version) den 3. Block startet und [89AB] (Variante) den 4. Block startet. Gambols Antwort macht es richtig.
Wolf
7
/^[0-9a-f]{8}-([0-9a-f]{4}-){3}[0-9a-f]{12}$/i
Prägnantere
41

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
Ivan Gabriele
quelle
39

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
Neeraj Sharma
quelle
Interessant, aber es sieht so aus, als würde es Bindestriche erwarten? Hier sind die vier regulären Ausdrücke, die derzeit verwendet werden - /^[0-9A-F]{8}-[0-9A-F]{4}-3[0-9A-F]{3}-[0-9A-F]{4}-[0-9A-F]{12}$/i und / oder /^[0-9A-F]{8}-[0-9A-F]{4}-4[0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}$/i und / oder /^[0-9A-F]{8}-[0-9A-F]{4}-5[0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}$/i und / oder /^[0-9A-F]{8}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{12}$/i
Ruffin
1
Validator unterstützt nur UUID v3-5, nicht v1
peteb
13

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.

Wolf
quelle
Dieser ist mein Favorit. Noch besser{?[0-9a-f]{8}-?[0-9a-f]{4}-?[1-5][0-9a-f]{3}-?[89ab][0-9a-f]{3}-?[0-9a-f]{12}}?
Mike Nelson
10

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
Evan Edwards
quelle
Das erste UUID-Segment der Null-UUID sollte 8 Nullen haben, nicht 7. Der bereitgestellte Regex hat es nicht mit 7 validiert.
Rich Seviora
2
Ihre sieht besser aus, lässt aber einige ungültige UUIDs zu, z. B.: abcdef00-0000-0000-0000-000000000000 Würde zu Ihrer Regex passen. Diese Regex entspricht gültigen UUIDs, einschließlich der Null:/^(?:[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
Luke
10

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;
}
Souhaieb
quelle
2

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)
B. Zoli
quelle
1

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}$");
}
userTatha
quelle
Ungefangener TypeError: s.matches ist keine Funktion
Deep Kakkar
1
Das angegebene Skript ist kein Javascript, was das OP verlangt hat.
StefanJanssen
Die Antwort wurde angepasst, um die obigen Kommentare zu adressieren. Die Lösung funktioniert jetzt wie erwartet.
DeeZone
Das ist immer noch nicht js.
ktilcu
1

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

James Morrison
quelle
1
A-fsollte A-Fso sein:/^([0-9a-fA-F]{8})-(([0-9a-fA-F]{4}\-){3})([0-9a-fA-F]{12})$/i
DeeZone
Wenn Sie den Fall (/ i) wiederholen, warum af und dann AF wiederholen?
Nimrod
0

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
blackcatweb
quelle
-1

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

Werner Diwischek
quelle