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

Question

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

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

Answer 1

В настоящее время UUID соответствуют указанным в RFC4122.

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

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

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

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

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

Answer 2

Если вы хотите проверить или проверить конкретную версию 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
  

Answer 3

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

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

Answer 4

Если вы используете 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

Answer 5

Если вы используете пакет uuid, этот пакет содержит логическую функцию проверки, которая сообщает вам, действителен ли uuid или нет.

Пример:

      import { validate as isValidUUID } from 'uuid';

if (!isValidUUID(tx.originId)) {
  return Promise.reject('Invalid OriginID');
}

Answer 6

Благодаря @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;
}

Answer 7

Помимо ответа Гамбола, который будет выполнять работу почти во всех случаях, все ответы, данные до сих пор, пропущены, так как групповое форматирование (8-4-4-4-12) не является обязательным для кодирования GUID в тексте. Он используется очень часто, но, очевидно, допустима также простая цепочка из 32 шестнадцатеричных цифр.^[1] регулярное выражение

/^[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] Речь идет опроверке переменной s, поэтому мы должны включить также недружественную пользователю форму.

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

Answer 8

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

Nil UUID - это специальная форма 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

Answer 9

если вы используете пакет uuid, вы можете импортировать валидацию и передать в нее идентификатор

      const { v4: uuidv4, validate } = require('uuid');

const { id } = request.params;
validate(id) ? true : false;

Answer 10

Если кто-то использует yup , библиотеку валидатора схемы JavaScript, эту функциональность можно реализовать с помощью приведенного ниже кода.

      const schema = yup.object().shape({
   uuid: yup.string().uuid()
 });
 const isValid = schema.isValidSync({uuid:"string"});

Answer 11

Слегка измененная версия приведенных выше ответов, написанная более кратко. Это подтвердит любой 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 раза

Answer 12

Я думаю, что ответ Гамбола почти идеален, но он неверно интерпретирует 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)

Answer 13

Версии с 1 по 5, без использования многоверсионного регулярного выражения, если версия не указана.

Answer 14

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

Answer 15

Небольшой метод, чтобы проверить, является ли String UUID.

public boolean isUUID(String s){
    return s.matches("^[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}$");
}

Answer 16

Это ответ на JS. Спасибо @userTatha

const isUUID = (uuid) => {
  return uuid.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}$'
 );
};

Answer 17

У меня есть эта функция, но по сути она такая же, как и принятый ответ.

      export default function isUuid(uuid: string, isNullable: boolean = false): boolean {
    return isNullable
        ? /^[0-9a-f]{8}-[0-9a-f]{4}-[0-5][0-9a-f]{3}-[089ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(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.test(uuid);
}

Answer 18

Вы можете проверить это с помощью следующей функции, особенно если ваша служба изначально создала UUID:

      import java.util.UUID;

...

public static boolean validateUUID(String uuid) {
        if (uuid == null) {
            return false;
        }
        try {
            if (!uuid.equals(UUID.fromString(uuid).toString())) {
                return false;
            }
        } catch (Exception e) {
            return false;
        }
        return true;
    }

Answer 19

Я добавил валидатор UUID в Apache Commons Validator. Он еще не объединен, но вы можете проголосовать за него здесь:

https://github.com/apache/commons-validator/pull/68

Answer 20

Я думаю, что лучше использовать статический метод 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