Jak przetestować poprawny UUID/GUID?

Regex na ratunek

/^[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');

Lub z nawiasami

/^\{?[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}‌​\}?$/

Jeśli chcesz sprawdzić lub zweryfikować konkretną wersję UUID, tutaj znajdują się odpowiednie wyrażenia regularne.

Zauważ, że jedyną różnicą jest numer wersji , który jest wyjaśniony w 4.1.3. Version rozdziale uuid 4122 RFC .

Numer wersji jest pierwszym znakiem trzeciej grupy : [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
  

Jeśli używasz Node.js dla rozwoju, zaleca się użycie pakietu o nazwie Validator. Zawiera wszystkie wyrażenia regularne wymagane do walidacji różnych wersji UUID, a także różne inne funkcje do walidacji.

Oto link npm: walidator

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

Dzięki @usertatha z jakąś modyfikacją

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

Obok Odpowiedzi Gambola , która wykona zadanie w prawie wszystkich przypadkach, Wszystkie odpowiedzi podane do tej pory brakowało, że zgrupowane formatowanie (8-4-4-4-12) nie jest obowiązkowe kodowanie GUID w tekście. Jest używany bardzo często, ale oczywiście również zwykły łańcuch 32 cyfr szesnastkowych może być ważny.^[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] pytanie dotyczy sprawdzania ing zmiennej s, więc powinniśmy uwzględnić również forma nieprzyjazna użytkownikowi.

• dlaczego są kreski w GUID. NET? - Stack Overflow plus Accepted answer
• Testowanie i Walidacja GUID (guid.us)
• Guid.Metoda ToString (String) (MSDN)

Wszystkie dotychczas opublikowane wyrażenia regularne typu nie działają na" type 0 " Nil uuid, zdefiniowanym w 4.1.7 RFC jako:

Nil UUID jest specjalną formą UUID, która jest określona tak, aby wszystkie 128 bitów było ustawione na zero: 00000000-0000-0000-0000-000000000000

Aby zmodyfikować odpowiedź Wilka:

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

Lub, aby poprawnie wykluczyć "typ 0" bez wszystkich zer, mamy następujące (dzięki Łukaszowi):

/^(?:[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

Myślę, że odpowiedź Gambola jest prawie idealna, ale źle interpretuje RFC 4122 § 4.1.1. Sekcja Variant trochę.

Obejmuje Wariant-1 UUIDs (10xx = 8..b), ale nie obejmuje wariantu-0 (0xxx = 0..7) i Wariant-2 (110x = ok..d) warianty zarezerwowane dla zgodności wstecznej, więc są technicznie poprawnymi uuid. Wariant-4 (111x = e..f) są rzeczywiście zarezerwowane do wykorzystania w przyszłości, więc nie są ważne obecnie.

Również typ 0 nie jest poprawny, że "cyfra" jest dozwolone jest tylko 0, jeśli jest to NIL UUID (jak wspomniano w ' s answer).

Więc myślę, że najdokładniejszym wyrażeniem regularnym zgodnym z aktualną specyfikacją RFC 4122 jest (łącznie z myślnikami):

/^([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)

Nieco zmodyfikowana wersja powyższych odpowiedzi napisana w bardziej zwięzły sposób. Spowoduje to walidację każdego GUID z myślnikami (jednak łatwo zmodyfikowane, aby myślniki były opcjonalne). Będzie to również obsługiwać wielkie i małe litery, które stały się konwencją niezależnie od specyfikacji:

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

Kluczem tutaj jest powtarzająca się część poniżej

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

Który po prostu powtarza 4 wzory znaków 3 razy

Myślę, że lepszym sposobem jest użycie statycznej metody fromString, aby uniknąć tych wyrażeń regularnych.

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

Z drugiej strony

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

Rzuca Javą.lang.IllegalArgumentException: Invalid uuid string: x

Użyj .metoda match () sprawdzająca, czy String jest UUID.

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}$");
}

Dobrym sposobem na zrobienie tego w Node jest użycie ajv pakietu ( https://github.com/epoberezkin/ajv).

const Ajv = require('ajv');
const ajv = new Ajv({ allErrors: true, useDefaults: 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