Búsqueda de sitios web

javascript - ¿Cómo probar un UUID/GUID válido?

¿Cómo comprobar si una variable contiene un identificador UUID/GUID válido?

Actualmente estoy interesado solo en validar los tipos 1 y 4, pero no debería ser una limitación para tus respuestas.

Respuesta #1

Actualmente, los UUID se especifican según RFC4122. Un caso límite a menudo descuidado es el UUID NIL, mencionado aquí. La siguiente expresión regular tiene esto en cuenta y devolverá una coincidencia para un UUID NIL. Vea a continuación un UUID que solo acepta UUIDs que no sean NIL. Ambas soluciones son para las versiones 1 a 5 (vea el primer carácter del tercer bloque).

Por lo tanto, para validar un 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

...asegura que tengas un UUID con formato canónico que sea de la Versión 1 a la 5 y que sea la Variante apropiada según RFC4122.

NOTA: Las llaves { y } no son canónicas. Son un artefacto de algunos sistemas y usos.

Fácil modificar la expresión regular anterior para cumplir con los requisitos de la pregunta original.

PISTA: grupo/capturas de expresiones regulares

Para evitar coincidir con UUID NIL:

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

Respuesta #2

Si quieres verificar o validar una versión específica de UUID, aquí están las expresiones regulares correspondientes.

Tenga en cuenta que la única diferencia es el número de versión, que se explica en el capítulo 4.1.3. Versión de la RFC 4122 de UUID.

El número de versión es el primer carácter del tercer 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

Respuesta #3

expresiones regulares al rescate

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

o con corchetes

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

Respuesta #4

Si usas el paquete uuid, este paquete trae una función de validación booleana que te dice si un uuid es válido o no.

Ejemplo :

import { validate as isValidUUID } from 'uuid';

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

Respuesta #5

Si estás usando Node.js para el desarrollo, se recomienda usar un paquete llamado Validator. Incluye todas las expresiones regulares necesarias para validar diferentes versiones de UUID, además de que obtienes varias otras funciones para la validación.

Aquí está el enlace de npm: Validator

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

Respuesta #6

gracias a @usertatha con algunas modificaciones

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

Respuesta #7

Además de la respuesta de Gambol que hará el trabajo en casi todos los casos, todas las respuestas dadas hasta ahora omitieron que el formato agrupado (8-4-4-4-12) no es obligatorio para codificar GUIDs en texto. Se usa con mucha frecuencia, pero obviamente también una simple cadena de 32 dígitos hexadecimales puede ser válida.[1] regexenh:

/^[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] La pregunta trata sobre comprobar variables, por lo que también deberíamos incluir la forma poco amigable para el usuario.

  • ¿Por qué hay guiones en un GUID de .NET? - Stack Overflow más respuesta aceptada
  • Probar y validar un GUID (guid.us)
  • Método Guid.ToString (String) (MSDN)

Respuesta #8

Todos los regex específicos de tipo publicados hasta ahora están fallando con el UUID Nil de "tipo 0", definido en 4.1.7 del RFC como:

El UUID nulo es una forma especial de UUID que se especifica para tener los 128 bits establecidos en cero: 00000000-0000-0000-0000-000000000000

Para modificar la respuesta 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

O, para excluir correctamente un "tipo 0" sin todos los ceros, tenemos lo siguiente (gracias 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

Respuesta #9

si usas el paquete uuid, puedes importar validate y pasarle el id

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

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

Artículos relacionados