Bagaimana cara menguji UUID / GUID yang valid?

Bagaimana cara memeriksa apakah variabel berisi pengidentifikasi UUID / GUID yang valid?

Saat ini saya hanya tertarik untuk memvalidasi tipe 1 dan 4, tetapi seharusnya tidak menjadi batasan untuk jawaban Anda.

Saat ini, UUID adalah sebagaimana ditentukan dalam RFC4122. Kasus tepi yang sering diabaikan adalah UUID NIL, yang disebutkan di sini . Regex berikut mempertimbangkan ini dan akan mengembalikan kecocokan untuk UUID NIL. Lihat di bawah ini untuk UUID yang hanya menerima UUID non-NIL. Kedua solusi ini adalah untuk versi 1 hingga 5 (lihat karakter pertama dari blok ketiga).

Karena itu untuk memvalidasi UUID ...

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

... memastikan Anda memiliki UUID yang diformat kanonik yaitu Versi 1 hingga 5 dan merupakan Varian yang sesuai sesuai RFC4122.

CATATAN: Kawat gigi {dan }bukan kanonik. Mereka adalah artefak dari beberapa sistem dan penggunaan.

Mudah untuk memodifikasi regex di atas untuk memenuhi persyaratan pertanyaan aslinya.

PETUNJUK: regex grup / tangkapan

Untuk menghindari pencocokan 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 untuk menyelamatkan

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

atau dengan kurung

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

Jika Anda ingin memeriksa atau memvalidasi versi UUID tertentu, berikut adalah regex yang sesuai.

Perhatikan bahwa satu-satunya perbedaan adalah nomor versi , yang dijelaskan dalam 4.1.3. Versionbab UUID 4122 RFC .

Nomor versi adalah karakter pertama dari grup ketiga [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

Jika Anda menggunakan Node.js untuk pengembangan, disarankan untuk menggunakan paket yang disebut Validator. Ini mencakup semua regex yang diperlukan untuk memvalidasi versi berbeda dari UUID plus Anda mendapatkan berbagai fungsi lainnya untuk validasi.

Inilah tautan npm: Validator

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

Selain jawaban Gambol yang akan melakukan pekerjaan dalam hampir semua kasus , semua jawaban yang diberikan sejauh ini terlewatkan sehingga pemformatan yang dikelompokkan (8-4-4-4-12) tidak wajib untuk menyandikan GUID dalam teks . Ini digunakan sangat sering tetapi jelas juga rantai polos 32 digit heksadesimal dapat valid. ^[1] _peningkatan regex :

/^[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] Pertanyaannya adalah tentang cek ing variabel s, jadi kami harus mencakup bentuk tidak ramah-pengguna juga.

• Mengapa ada tanda hubung dalam. NET GUID? - Stack Overflow plus Jawaban yang diterima
• Uji dan validasikan GUID (guid.us)
• Guid.ToString Method (String) (MSDN)

Semua regex spesifik tipe yang diposting sejauh ini gagal pada UUID "tipe 0", didefinisikan dalam 4.1.7 dari RFC sebagai:

NIL UUID adalah bentuk khusus UUID yang ditentukan untuk mengatur semua 128 bit menjadi nol: 00000000-0000-0000-0000-000000000000

Untuk memodifikasi jawaban Wolf:

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

Atau, untuk mengecualikan "tipe 0" dengan benar tanpa semua nol, kami memiliki yang berikut (terima kasih kepada 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

terima kasih kepada @usertatha dengan beberapa modifikasi

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

Saya pikir jawaban Gambol hampir sempurna, tetapi salah mengartikan RFC 4122 § 4.1.1. Bagian varian sedikit.

Ini mencakup Varian-1 UUIDs (10xx = 8..b), tetapi tidak mencakup Varian-0 (0xxx = 0..7) dan varian Varian-2 (110x = c..d) yang dicadangkan untuk kompatibilitas ke belakang, jadi itu adalah UUID yang secara teknis valid. Varian-4 (111x = e..f) memang disediakan untuk penggunaan di masa mendatang, sehingga saat ini tidak valid.

Juga, 0 type tidak valid, "digit" itu hanya boleh 0 jika itu NIL UUID (seperti disebutkan dalam jawaban Evan ).

Jadi saya pikir regex paling akurat yang sesuai dengan spesifikasi RFC 4122 saat ini adalah (termasuk tanda hubung):

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

Gunakan metode .match () untuk memeriksa apakah String adalah 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}$");
}

Versi yang sedikit dimodifikasi dari jawaban di atas ditulis dengan cara yang lebih ringkas. Ini akan memvalidasi GUID apa pun dengan tanda hubung (namun mudah dimodifikasi untuk menjadikan tanda hubung opsional). Ini juga akan mendukung karakter huruf besar dan kecil yang telah menjadi konvensi terlepas dari spesifikasinya:

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

Kuncinya di sini adalah bagian berulang di bawah ini

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

Yang hanya mengulangi pola 4 char 3 kali

Cara yang baik untuk melakukannya di Node adalah dengan menggunakan ajvpaket ( 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

Saya pikir cara yang lebih baik adalah menggunakan metode statis dari Strtring untuk menghindari ekspresi reguler itu.

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

Di samping itu

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

throws java.lang.IllegalArgumentException: String UUID tidak valid: x