Como testar UUID / GUID válido?

Como verificar se a variável contém um identificador UUID / GUID válido?

No momento, estou interessado apenas na validação dos tipos 1 e 4, mas não deve ser uma limitação para suas respostas.

Atualmente, os UUIDs são os especificados na RFC4122. Um caso de borda muitas vezes negligenciado é o NIL UUID, observado aqui . A seguinte expressão regular leva isso em consideração e retornará uma correspondência para um NUUUID. Veja abaixo um UUID que aceita apenas UUIDs não NIL. Ambas as soluções são para as versões 1 a 5 (consulte o primeiro caractere do terceiro bloco).

Portanto, para validar um 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

... garante que você tenha um UUID formatado canonicamente que seja da versão 1 a 5 e seja a variante apropriada conforme RFC4122.

NOTA: Suspensórios {e }não são canônicos. Eles são um artefato de alguns sistemas e usos.

Fácil modificar a regex acima para atender aos requisitos da pergunta original.

DICA: grupo / captura de expressões regulares

Para evitar a correspondência de 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 para o resgate

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

ou com colchetes

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

Se você deseja verificar ou validar uma versão UUID específica, aqui estão as regexes correspondentes.

Observe que a única diferença é o número da versão , explicado no 4.1.3. Versioncapítulo do RFC UUID 4122 .

O número da versão é o primeiro caractere do terceiro grupo [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

Se você estiver usando o Node.js. para desenvolvimento, é recomendável usar um pacote chamado Validator. Ele inclui todas as expressões regulares necessárias para validar versões diferentes de UUIDs, além de você obter várias outras funções para validação.

Aqui está o link npm: Validator

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

Ao lado da resposta de Gambol, que fará o trabalho em quase todos os casos , todas as respostas dadas até agora perderam a formatação agrupada (8-4-4-4-12) não é obrigatória para codificar GUIDs em texto . É usado com muita frequência, mas obviamente também uma cadeia simples de 32 dígitos hexadecimais pode ser válida. ^[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] A questão é verificar as variáveis s, portanto devemos incluir também o formulário não amigável ao usuário.

• Por que existem traços em um GUID do .NET? - Estouro de pilha mais resposta aceita
• Teste e valide um GUID (guid.us)
• Método Guid.ToString (String) (MSDN)

Todas as regexes específicas de tipo postadas até agora estão falhando no UUID "tipo 0" nulo, definido em 4.1.7 da RFC como:

O UUID nulo é uma forma especial de UUID especificada para ter todos os 128 bits definidos como zero: 00000000-0000-0000-0000-000000000000

Para modificar a resposta de 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

Ou, para excluir corretamente um "tipo 0" sem todos os zeros, temos o seguinte (graças a 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

graças a @usertatha com algumas modificações

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

Acho que a resposta de Gambol é quase perfeita, mas interpreta mal a RFC 4122 § 4.1.1. Seção de variantes um pouco.

Abrange UUIDs da variante-1 (10xx = 8..b), mas não abrange as variantes da variante-0 (0xxx = 0..7) e da variante-2 (110x = c..d) que são reservadas para compatibilidade com versões anteriores, então eles são UUIDs tecnicamente válidos. A variante-4 (111x = e..f) é realmente reservada para uso futuro, portanto, elas não são válidas no momento.

Além disso, o tipo 0 não é válido, esse "dígito" só pode ser 0 se for um NIL UUID (como mencionado na resposta de Evan ).

Então eu acho que o regex mais preciso que está em conformidade com a especificação atual RFC 4122 é (incluindo hífens):

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

Use o método .match () para verificar se 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}$");
}

Uma versão ligeiramente modificada das respostas acima, escrita de maneira mais concisa. Isso validará qualquer GUID com hífens (por mais que seja facilmente modificado para tornar os hífens opcionais). Isso também suporta caracteres maiúsculos e minúsculos que se tornaram a convenção, independentemente da especificação:

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

A chave aqui é a parte repetida abaixo

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

Que simplesmente repete os 4 padrões de caracteres 3 vezes

Uma boa maneira de fazer isso no Node é usar o ajvpacote ( 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

Eu acho que uma maneira melhor é usar o método estático fromString para evitar essas expressões regulares.

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

Por outro lado

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

lança java.lang.IllegalArgumentException: string UUID inválida: x