Как проверить действительный UUID / GUID?

Как проверить, содержит ли переменная действительный идентификатор UUID / GUID?

В настоящее время меня интересует только проверка типов 1 и 4, но это не должно быть ограничением ваших ответов.

В настоящее время UUID соответствуют указанным в RFC4122. Часто забытый крайний случай - NIL UUID, отмеченный здесь . Следующее регулярное выражение учитывает это и возвращает совпадение для NIL UUID. См. Ниже UUID, который принимает только не-NIL UUID. Оба эти решения предназначены для версий с 1 по 5 (см. Первый символ третьего блока).

Поэтому, чтобы проверить 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

... гарантирует, что у вас есть канонически отформатированный UUID версии 1-5 и соответствующий вариант согласно RFC4122.

ПРИМЕЧАНИЕ: брекеты {и }не являются каноническими. Они являются артефактом некоторых систем и обычаев.

Легко изменить приведенное выше регулярное выражение, чтобы удовлетворить требования исходного вопроса.

СОВЕТ: регулярное выражение группы / захватывает

Чтобы избежать совпадения 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

регулярное выражение на помощь

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

или с кронштейнами

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

Если вы хотите проверить или проверить конкретную версию UUID, вот соответствующие регулярные выражения.

Обратите внимание, что единственным отличием является номер версии , который объясняется в 4.1.3. Versionглаве UUID 4122 RFC .

Номер версии является первым символом третьей группы [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

Если вы используете Node.js для разработки, рекомендуется использовать пакет под названием Validator. Он включает в себя все регулярные выражения, необходимые для проверки различных версий UUID, плюс вы получаете различные другие функции для проверки.

Вот ссылка npm: Validator

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

Кроме ответа Гамбола, который будет выполнять работу почти во всех случаях , все ответы, представленные до сих пор, пропустили, что групповое форматирование (8-4-4-4-12) не является обязательным для кодирования GUID в тексте . Он используется очень часто, но, очевидно, допустима также простая цепочка из 32 шестнадцатеричных цифр. ^[1] регулярное выражение _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] Речь идет о регистрации ING переменной s, поэтому мы должны включить пользователь недружественной формы , а также.

• Почему в .NET GUID есть тире? - переполнение стека плюс принятый ответ
• Протестируйте и подтвердите GUID (guid.us)
• Метод Guid.ToString (String) (MSDN)

Все приведенные к настоящему времени типовые регулярные выражения не работают с нулевым UUID типа 0, определенным в 4.1.7 RFC:

UUID nil - это специальная форма UUID, в которой все 128 бит установлены на ноль: 00000000-0000-0000-0000-000000000000

Чтобы изменить ответ Вольфа:

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

Или, чтобы правильно исключить «тип 0» без всех нулей, у нас есть следующее (спасибо Люку):

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

благодаря @usertatha с некоторыми изменениями

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

Я думаю, что ответ Гамбола почти идеален, но он неверно истолковывает RFC 4122 § 4.1.1. Вариант раздела немного.

Он охватывает варианты UUID варианта 1 (10xx = 8..b), но не охватывает варианты варианта 0 (0xxx = 0,7) и варианта 2 (110x = c..d), которые зарезервированы для обратной совместимости, поэтому они являются технически действительными UUID. Вариант-4 (111x = e..f) действительно зарезервирован для будущего использования, поэтому в настоящее время он недействителен.

Кроме того, тип 0 недопустим, эта цифра может быть только 0, если это NIL UUID (как упомянуто в ответе Эвана ).

Поэтому я думаю, что наиболее точное регулярное выражение, соответствующее текущей спецификации RFC 4122, (включая дефисы):

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

Используйте метод .match (), чтобы проверить, является ли String 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}$");
}

Слегка измененная версия приведенных выше ответов написана более лаконично. Это проверит любой GUID с дефисами (однако его легко изменить, чтобы сделать дефис необязательным). Это также будет поддерживать символы верхнего и нижнего регистра, которые стали соглашением независимо от спецификации:

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

Ключ здесь - повторяющаяся часть ниже

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

Который просто повторяет 4 паттерна 3 символа

Хороший способ сделать это в Node - использовать ajvпакет ( 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

Я думаю, что лучше использовать статический метод fromString, чтобы избежать этих регулярных выражений.

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

С другой стороны

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

throws java.lang.IllegalArgumentException: Неверная строка UUID: x