Comment tester un UUID / GUID valide?

Comment vérifier si la variable contient un identifiant UUID / GUID valide?

Je ne suis actuellement intéressé que par la validation des types 1 et 4, mais cela ne devrait pas limiter vos réponses.

Actuellement, les UUID sont tels que spécifiés dans la RFC4122. Un cas de bord souvent négligé est le NIL UUID, noté ici . Le regex suivant en tient compte et renverra une correspondance pour un NU UUID. Voir ci-dessous pour un UUID qui accepte uniquement les UUID non NIL. Ces deux solutions concernent les versions 1 à 5 (voir le premier caractère du troisième bloc).

Par conséquent, pour valider 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

... garantit que vous disposez d'un UUID au format canonique qui est la version 1 à 5 et est la variante appropriée selon RFC4122.

REMARQUE: les accolades {et }ne sont pas canoniques. Ils sont un artefact de certains systèmes et usages.

Facile à modifier l'expression rationnelle ci-dessus pour répondre aux exigences de la question d'origine.

CONSEIL: groupe regex / captures

Pour éviter de faire correspondre NU 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 à la rescousse

/^[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 avec supports

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

Si vous souhaitez vérifier ou valider une version UUID spécifique, voici les expressions rationnelles correspondantes.

Notez que la seule différence est le numéro de version , qui est expliqué dans le 4.1.3. Versionchapitre de l' UUID 4122 RFC .

Le numéro de version est le premier caractère du troisième groupe [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

Si vous utilisez Node.js pour le développement, il est recommandé d'utiliser un package appelé Validator. Il comprend toutes les expressions rationnelles requises pour valider différentes versions d'UUID et vous obtenez diverses autres fonctions pour la validation.

Voici le lien npm: Validateur

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

À côté de la réponse de Gambol qui fera l'affaire dans presque tous les cas , toutes les réponses données jusqu'à présent ont manqué que le formatage groupé (8-4-4-4-12) n'est pas obligatoire pour coder les GUID en texte . Il est utilisé très souvent, mais évidemment, une chaîne simple de 32 chiffres hexadécimaux peut être valide. ^[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] La question est de vérifier ing variables s, donc nous devrions inclure le formulaire peu convivial ainsi.

• Pourquoi y a-t-il des tirets dans un GUID .NET? - Dépassement de pile plus réponse acceptée
• Testez et validez un GUID (guid.us)
• Méthode Guid.ToString (chaîne) (MSDN)

Tous les regex spécifiques au type publiés jusqu'à présent échouent sur le "type 0" UIL Nil, défini dans 4.1.7 du RFC comme:

L'UUID nil est une forme spéciale d'UUID spécifiée pour que tous les 128 bits soient mis à zéro: 00000000-0000-0000-0000-000000000000

Pour modifier la réponse 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, pour exclure correctement un "type 0" sans tous les zéros, nous avons ce qui suit (grâce à 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

merci à @usertatha avec quelques modifications

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

Je pense que la réponse de Gambol est presque parfaite, mais elle interprète mal le RFC 4122 § 4.1.1. Section variante un peu.

Il couvre les UUID Variant-1 (10xx = 8..b), mais ne couvre pas les variantes Variant-0 (0xxx = 0..7) et Variant-2 (110x = c..d) qui sont réservées pour la compatibilité descendante, ce sont donc des UUID techniquement valides. La variante-4 (111x = e..f) est en effet réservée pour une utilisation future, elles ne sont donc pas valides actuellement.

De plus, le type 0 n'est pas valide, ce "chiffre" ne peut être égal à 0 que si c'est un NU UUID (comme mentionné dans la réponse d'Evan ).

Je pense donc que l'expression rationnelle la plus précise qui est conforme à la spécification RFC 4122 actuelle est (y compris les tirets):

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

Utilisez la méthode .match () pour vérifier si String est 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}$");
}

Une version légèrement modifiée des réponses ci-dessus rédigées de manière plus concise. Cela validera tout GUID avec des tirets (cependant facilement modifié pour rendre les tirets facultatifs). Cela prendra également en charge les majuscules et les minuscules, ce qui est devenu la convention quelle que soit la spécification:

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

La clé ici est la partie répétitive ci-dessous

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

Qui répète simplement les 4 motifs de caractère 3 fois

Une bonne façon de le faire dans Node est d'utiliser le ajvpackage ( 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

Je pense qu'une meilleure façon est d'utiliser la méthode statique fromString pour éviter ces expressions régulières.

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

D'autre part

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

lève java.lang.IllegalArgumentException: chaîne UUID non valide: x