Avez-vous besoin d'un identifiant qui n'entrera pas en conflit avec un autre créé par quelqu'un d'autre, sur une machine dont vous n'avez jamais entendu parler, sans demander la permission à personne ? C'est exactement le rôle d'un UUID. Il s'agit d'un nombre de 128 bits, écrit sous la forme de 36 caractères selon le schéma familier 8-4-4-4-12, et toute sa conception vise à ce que deux d'entre eux ne soient jamais identiques, même si rien ne coordonne qui obtient lequel. Ce générateur gratuit les crée dans votre navigateur : choisissez une version dans Version, indiquez combien vous en avez besoin dans Quantité, puis cliquez sur Générer. La page s'ouvre sur un seul v4, la version recherchée par la plupart des projets, de sorte qu'un premier identifiant est à portée de clic.
Chaque identifiant est généré par votre navigateur via la Web Crypto API. La version 4 utilise crypto.randomUUID() lorsque le navigateur le propose, et crypto.getRandomValues() dans le cas contraire, soit une source d'aléatoire cryptographiquement forte plutôt qu'une fonction pseudo-aléatoire JavaScript comme Math.random(). La version 7 place un horodatage de 48 bits en millisecondes au début, puis un compteur de 12 bits qui s'incrémente au sein de la même milliseconde, puis 62 bits aléatoires, ce qui constitue la méthode de tri décrite dans le RFC 9562 ; ce compteur explique pourquoi un lot de mille identifiants sort dans l'ordre plutôt que mélangé. La version 1 combine un horodatage avec un identifiant de nœud aléatoire dont le bit de multidiffusion est activé, de sorte qu'elle ne contient jamais l'adresse de votre carte réseau comme le faisaient les implémentations originales des années 1990. Les versions 3 et 5 ne sont pas du tout aléatoires : elles hachent un espace de noms avec un nom, en utilisant respectivement MD5 et SHA-1, et ce hachage se produit également sur votre appareil. Rien n'est envoyé à un serveur, rien n'est enregistré et, une fois la page chargée, elle continue de fonctionner sans connexion.
Version est le champ qui décide de tout le reste. La version 4 est composée de 122 bits aléatoires sans aucune structure : c'est l'option par défaut et la bonne réponse lorsqu'un identifiant doit seulement être unique. La version 7 conserve 62 bits aléatoires mais commence par l'heure de sa création, de sorte qu'un ensemble de ces identifiants se trie dans l'ordre de leur création ; c'est la version à privilégier lorsque l'identifiant deviendra une clé de base de données. La version 1 est le schéma temporel original, conservé ici pour les systèmes qui le demandent encore. Les versions 3 et 5 forment un duo à part : elles sont déterministes, ce qui signifie que les mêmes entrées produisent toujours le même identifiant, et elles nécessitent deux champs supplémentaires : Espace de noms, qui est l'un des espaces standards DNS, URL, OID et X.500 ou un espace Personnalisé de votre choix, et Nom, la chaîne de caractères à identifier. Fournissez à la v5 l'espace de noms URL et https://example.com/a et vous obtiendrez le même UUID aujourd'hui, demain et sur la machine de n'importe qui d'autre. C'est pourquoi Quantité disparaît lorsque la v3 ou la v5 est sélectionnée : mille copies d'une valeur déterministe ne seraient que mille copies d'une valeur déterministe. Pour toutes les autres versions, Quantité va de 1 à 1000.
Quatre interrupteurs modifient la forme du résultat sans altérer les 128 bits sous-jacents. Majuscules imprime les chiffres hexadécimaux en lettres capitales, Sans tirets donne la forme compacte de 32 caractères préférée par certaines colonnes et noms de fichiers, et Accolades enveloppe la valeur entre { }, soit la forme que Windows et le monde .NET appellent un GUID. Sous Paramètres avancés, urn:uuid: ajoute le préfixe qui en fait un URN formel ; il désactive Accolades et Sans tirets lorsqu'il est activé, car la norme autorise exactement une forme d'URN et c'est la forme canonique avec tirets. Format de copie décide comment un lot est assemblé lorsque vous le récupérez : un par ligne, séparés par des virgules, ou chaque valeur entre guillemets suivie d'une virgule, ce qui permet de le coller directement dans un tableau dans le code. Sous le résultat se trouve une ligne qui indique l'entropie en bits — 122 pour la v4, 62 pour la v7 — et, pour la v7, l'horodatage codé dans le premier identifiant du lot, de sorte que l'heure à l'intérieur de la valeur est visible plutôt qu'implicite. Tout copier et Sauvegarder dans un fichier respectent tous deux Format de copie. Historique conserve vos 10 derniers lots dans votre propre navigateur : cliquez sur l'un d'eux pour le ramener, copiez ou supprimez une entrée unique, ou effacez le tout. Effacer vide le résultat tout en conservant vos paramètres, et au-delà de 50 identifiants la liste devient un seul bloc déroulant au lieu de cinquante lignes.
La chose la plus conséquente sur cette page est la différence entre la v4 et la v7 en tant que clé primaire, et ce n'est pas une question de goût. Les index de bases de données sont des arbres maintenus triés, et l'endroit où atterrit une nouvelle clé dans cet ordre décide de la charge de travail de l'insertion. Une clé v4 est aléatoire, de sorte que des insertions consécutives atterrissent dans des coins non liés de l'index : les pages qui étaient pleines se divisent, les parties de l'arbre que la base de données garde en mémoire sont rarement les parties dont la prochaine insertion a besoin, et l'index finit par être plus grand et plus fragmenté que ne le justifient les lignes vers lesquelles il pointe. Une clé v7 commence par la milliseconde actuelle, de sorte que des insertions consécutives atterrissent les unes à côté des autres sur le bord droit de l'arbre, ce qui est le modèle produit par un entier auto-incrémenté et le modèle autour duquel les structures d'index ont été construites. C'est là tout le compromis : la v7 vous offre le comportement d'insertion d'une clé séquentielle tout en conservant la propriété qui vous a fait choisir les UUID en premier lieu, à savoir que n'importe qui peut en forger un sans demander à un serveur. Ce qu'il en coûte, c'est que l'heure de création est désormais lisible à l'intérieur de l'identifiant, et savoir si cela a de l'importance est une question concernant vos données, pas le format.
Rien ne vérifie jamais qu'un UUID est unique ; sa taille est la garantie. Il n'y a pas de registre, pas d'aller-retour avec un serveur, pas de recherche — un générateur produit un nombre et vous le remet, et la raison pour laquelle deux d'entre eux n'entrent pas en collision est simplement qu'il existe 2^122 valeurs v4 possibles, soit environ 5,3 sextillions. Le paradoxe des anniversaires est la façon honnête de dimensionner cela : il vous faudrait environ 2,7 trillions d'identifiants avant qu'il n'y ait une chance sur deux que deux d'entre eux correspondent, ce qui représente un milliard de nouveaux UUID chaque seconde pendant 86 ans. Il est utile d'être précis sur ce que cela promet et ne promet pas. C'est une garantie statistique, pas arithmétique, et elle ne tient que si le hasard sous-jacent est réel — un générateur mal initialisé, ou une machine virtuelle clonée avec sa réserve d'entropie, la brise d'une manière que le format ne peut détecter. La version 7 restreint encore plus la question : à l'intérieur d'une seule milliseconde, un générateur ne peut pas se répéter du tout, car le compteur s'incrémente au lieu de lancer les dés, et entre des générateurs indépendants, les 62 bits aléatoires font le travail.
Un UUID est un identifiant, pas un mot de passe. La version 4 est imprévisible, ce qui tente les gens de la traiter comme un secret — un lien de réinitialisation de mot de passe, une URL impossible à deviner, un jeton de session, une clé d'API. L'imprévisibilité est réelle, mais le secret est une propriété de la façon dont une valeur est manipulée, et les identifiants sont manipulés négligemment par conception (une notion critique avec les lois sur la protection des renseignements personnels) : ils se retrouvent dans des URL qui finissent dans l'historique des navigateurs, les journaux de serveurs, les en-têtes referer et les outils d'analyse, et ils sont collés dans des messages de clavardage. Les autres versions sont de pires candidates encore. La version 1 et la version 7 encodent toutes deux le moment de leur création, de sorte que quiconque en détient un sait approximativement quand il a été créé et peut restreindre le voisinage de tout ce qui a été créé en même temps. Les versions 3 et 5 sont déterministes par nature : un UUID v5 d'une adresse courriel n'est pas un secret haché, c'est une valeur que toute personne possédant la même adresse peut calculer en une seconde. Utilisez un UUID pour nommer une chose. Utilisez un générateur de mots de passe, ou un jeton provenant d'une bibliothèque conçue pour les secrets, lorsque la valeur doit rester inconnue.
Pourquoi choisir ce générateur d'UUID ?
- Génération uniquement dans le navigateur : les identifiants sont créés sur votre appareil et ne sont jamais envoyés nulle part
- Aléatoire de la Web Crypto API : cryptographiquement sécurisé, pas de Math.random()
- Cinq versions au même endroit : v1, v3, v4, v5 et v7, sans changer d'outil
- Une v7 véritablement ordonnée : un compteur à l'intérieur de la milliseconde, comme le décrit le RFC 9562
- Les v3 et v5 déterministes avec les quatre espaces de noms standards ou le vôtre
- Jusqu'à 1000 à la fois, avec une liste déroulante compacte au-delà de cinquante
- Toutes les formes courantes : avec tirets, nue, en majuscules, entre accolades ou en URN urn:uuid:
- Copie sous forme de lignes, de virgules ou de valeurs entre guillemets qui se collent directement dans le code
- Illimité et gratuit : pas d'inscription, pas de limite d'utilisation, rien sur nos serveurs
Les UUID apparaissent partout où quelque chose doit être nommé avant que rien ne puisse confirmer que le nom est libre. Le code de l'application les forge pour les lignes qu'il s'apprête à insérer, de sorte que l'objet a une identité avant même d'avoir atteint la base de données et qu'un client peut y faire référence pendant que l'écriture est encore en vol. Les systèmes distribués s'appuient davantage sur eux : un service public bilingue dont plusieurs équipes écrivent dans la même table, un système de santé qui rapproche des dossiers créés au même moment dans deux provinces, une plateforme logistique dont les appareils créent des enregistrements hors couverture, et une file qui doit reconnaître le message déjà traité — aucun de ceux-ci ne peut attendre son tour pour un compteur partagé. La version 5 couvre un besoin différent, qui est un identifiant stable dérivé de quelque chose que vous possédez déjà : le même document, la même URL ou le même compte correspond toujours au même UUID, de sorte qu'une importation peut s'exécuter deux fois sans rien dupliquer. Ailleurs, ils sont simplement le format qu'un système exige — un identifiant de corrélation enfilé dans les journaux et les traces, un nom de fichier qui n'entrera pas en collision lorsque les téléversements de mille utilisateurs atterriront dans le même bucket, une clé de registre Windows, des données de test qui doivent ressembler à des données réelles.
Quelques limites honnêtes méritent d'être connues. Un lot correspond à une version : la valeur dans Version s'applique à tout ce qu'il contient, de sorte qu'une série de v4 et une série de v7 constituent deux lots distincts. Ceci est un générateur, pas un inspecteur — coller un UUID pour relire sa version ou son horodatage n'est pas quelque chose que cette page fait. Sauvegarder dans un fichier écrit un fichier texte brut plutôt qu'un CSV ou JSON. La version 7 révèle ouvertement quand elle a été créée, à la milliseconde près, ce qui est un véritable compromis plutôt qu'un défaut, et la version 1 divulgue le temps de la même manière ; si cela pose un problème pour vos données, la version 4 est la version qui ne dit rien à personne. Deux valeurs spéciales de la norme ne sont pas des versions et ne sont donc pas des options dans Version, mais vous pouvez les copier à partir d'ici : l'UUID nil, 00000000-0000-0000-0000-000000000000, et l'UUID max, ffffffff-ffff-ffff-ffff-ffffffffffff. Tout sur cette page suit le RFC 9562, la spécification qui a remplacé le RFC 4122 en 2024, de sorte que la sortie est acceptée par n'importe quelle bibliothèque, base de données ou API qui gère les UUID de toute façon. Dans ces limites, la garantie est forte : chaque identifiant est construit selon la norme, à partir d'un aléatoire cryptographiquement sécurisé, sur votre propre machine, et personne d'autre ne le voit jamais.