Les outils UUID de ToolDeck couvrent tous les principaux formats d'identifiant unique en un seul endroit. La collection comprend : le Générateur UUID v4 pour des IDs aléatoires cryptographiquement forts ; le Générateur UUID v7 pour des clés primaires triables par horodatage ; le Générateur UUID v1 pour des identifiants basés sur le temps et l'adresse MAC ; le Générateur UUID v2 pour les systèmes DCE hérités ; le Générateur UUID v3 pour des IDs déterministes basés sur MD5 ; le Générateur ULID pour des chaînes compactes et triables ; le Générateur NanoID pour des tokens courts et sécurisés pour URL ; le Générateur CUID pour le format original résistant aux collisions ; le Générateur CUID2 pour son successeur moderne ; et le Décodeur UUID pour inspecter les identifiants existants. Tous les outils fonctionnent entièrement dans ton navigateur via la Web Crypto API — aucune donnée n'est transmise à aucun serveur, aucun compte requis.
Que sont les outils UUID et d'ID unique ?
Un UUID (Identifiant Universel Unique) est un identifiant de 128 bits standardisé dans la RFC 9562 (anciennement RFC 4122). Écrit comme 32 caractères hexadécimaux au format 8-4-4-4-12, un UUID ressemble à : 550e8400-e29b-41d4-a716-446655440000. Le standard définit plusieurs versions, chacune utilisant une stratégie différente pour garantir l'unicité : nombres aléatoires, horodatages ou hachage déterministe.
Les UUID ont été conçus pour permettre aux systèmes distribués de générer des identifiants sans coordinateur central. Que tu assignes une clé primaire dans PostgreSQL, génères un token de session dans une application web, ou nommes un fichier dans un stockage d'objets, les UUID permettent à chaque nœud de ton système de créer un ID globalement unique de manière indépendante — avec une probabilité de collision si faible qu'elle est négligeable en pratique.
Au-delà du standard UUID, plusieurs formats alternatifs d'ID unique ont émergé pour répondre à des limitations spécifiques : ULID et UUID v7 ajoutent une triabilité lexicographique pour l'efficacité des index de base de données ; NanoID réduit la taille pour les URLs et les cookies ; CUID2 priorise la résistance aux collisions basée sur les empreintes pour la génération côté client à haut volume.
Pourquoi utiliser les outils UUID sur ToolDeck ?
Les outils UUID de ToolDeck fonctionnent entièrement dans ton navigateur. Aucun appel API, aucun traitement côté serveur, aucune donnée enregistrée. Chaque générateur utilise la Web Crypto API (crypto.getRandomValues) pour une entropie cryptographiquement forte — la même source que les navigateurs utilisent pour le matériel de clé TLS.
🔐Entropie cryptographiquement forte
Tous les générateurs basés sur l'aléatoire (UUID v4, NanoID, CUID2) utilisent crypto.getRandomValues, pas Math.random. Le résultat convient aux cas d'usage sensibles à la sécurité comme les tokens de session et les clés API.
📦Tous les principaux formats d'ID en un seul endroit
UUID v1 à v7, ULID, NanoID, CUID et CUID2 — tous les formats dont un développeur a besoin, avec des options pour générer en masse et copier en un clic.
🔍Décode et inspecte les IDs existants
Le Décodeur UUID extrait la version, la variante, l'horodatage et les champs de nœud de n'importe quel UUID. Utile pour le débogage, l'audit et la compréhension des IDs hérités dans ta base de code.
⚡Sans configuration, fonctionne hors ligne
Pas d'installation, pas d'inscription, pas de dépendances d'exécution. Ouvre la page et génère. Tous les outils fonctionnent hors ligne une fois la page chargée — utile dans les environnements isolés ou les réseaux restreints.
Cas d'usage des outils UUID
Les identifiants uniques apparaissent à chaque couche de la stack. Voici comment différents profils utilisent les outils de génération UUID :
Clés primaires de base de données
Les ingénieurs backend assignent UUID v4 ou UUID v7 comme clés primaires dans PostgreSQL, MySQL et MongoDB. Le préfixe d'horodatage de UUID v7 maintient les lignes physiquement ordonnées sur le disque, évitant les divisions de page sur les workloads à forte insertion.
État frontend et IDs de composants
Les développeurs frontend utilisent NanoID ou UUID v4 pour générer des clés React stables pour les éléments de liste créés dynamiquement, des IDs de dialogue pour les attributs d'accessibilité ARIA, et des tokens d'idempotence pour les soumissions de formulaires.
Streams d'événements distribués
Dans les systèmes orientés événements, chaque événement a besoin d'un ID globalement unique et triable. Les ingénieurs DevOps et plateforme utilisent ULID ou UUID v7 pour que les consommateurs Kafka, les agrégateurs de logs et les pistes d'audit puissent être triés par heure de création sans champ d'horodatage secondaire.
Génération de données de test
Les ingénieurs QA génèrent des lots d'UUID en masse pour peupler les bases de données de test avec des IDs réalistes et non séquentiels. UUID v3 ou v5 déterministes leur permettent de régénérer le même ID à partir d'une entrée connue — utile pour des fixtures de test reproductibles.
IDs de corrélation dans les microservices
Attacher un UUID à chaque requête HTTP entrante et le propager entre les appels de service (en-tête X-Request-ID) permet aux systèmes de tracing distribué de corréler les logs entre les services. UUID v4 est le standard de facto pour la corrélation de requêtes.
Nommage d'assets et de ressources
Les clés de stockage d'objets (S3, GCS, Cloudflare R2) et les noms de fichiers d'assets CDN intègrent souvent un UUID pour éviter les collisions de cache et le devinement d'URL. Le format compact de 21 caractères de NanoID réduit la longueur d'URL par rapport aux UUIDs complets de 36 caractères.
Référence des versions et formats UUID
Le tableau ci-dessous compare toutes les versions UUID avec les alternatives les plus utilisées. Utilise-le pour identifier rapidement quel format correspond à tes besoins.
| Identifiant | Algorithme | Triable | Déterministe | Idéal pour |
|---|
| UUID v4 | Aléatoire (CSPRNG) | — | — | IDs polyvalents, tokens de session, clés primaires |
| UUID v7 | Horodatage Unix ms + aléatoire | ✓ | — | Clés primaires triables, IDs d'événements distribués (RFC 9562) |
| UUID v1 | Horodatage + adresse MAC | ✓ | — | IDs triés par temps, systèmes à nœud unique, compatibilité héritée |
| UUID v3 | Espace de noms + nom + MD5 | — | ✓ | IDs reproductibles à partir d'entrées connues (DNS, URLs) |
| UUID v5 | Espace de noms + nom + SHA-1 | — | ✓ | Identique à v3 avec un hash plus fort ; préférer v5 à v3 |
| UUID v2 | Horodatage + UID/GID DCE | ✓ | — | Environnements POSIX/DCE hérités ; éviter pour les nouveaux projets |
| ULID | Préfixe d'horodatage + aléatoire | ✓ | — | IDs triables, sécurisés pour URL, sans tirets (26 caractères) |
| NanoID | Aléatoire (CSPRNG), alphabet sécurisé pour URL | — | — | IDs courts pour URLs, cookies, attributs HTML (21 caractères) |
| CUID2 | Empreinte + horodatage + aléatoire | — | — | Génération côté client à haut volume, résistant aux collisions |
UUID v3 et v5 sont déterministes : le même espace de noms + nom produit toujours le même UUID. Tous les autres formats génèrent une nouvelle valeur à chaque appel.
Comment choisir le bon outil UUID
Le bon identifiant dépend de tes besoins en termes de triabilité, taille et déterminisme. Utilise ce guide de décision :
- 1
Si tu as besoin d'un ID unique polyvalent sans exigences particulières → Générateur UUID v4 - 2
Si tu as besoin d'IDs qui se trient chronologiquement et sont compatibles avec le standard UUID → Générateur UUID v7 - 3
Si tu as besoin d'IDs triés par temps avec un horodatage intégré pour des systèmes à nœud unique ou à faible concurrence → Générateur UUID v1 - 4
Si tu as besoin d'IDs triables, sécurisés pour URL et sans tirets → Générateur ULID - 5
Si tu as besoin d'IDs compacts et sécurisés pour URL plus courts qu'un UUID complet → Générateur NanoID - 6
Si tu génères beaucoup d'IDs côté client et as besoin d'une forte résistance aux collisions → Générateur CUID2 - 7
Si tu as besoin du format CUID v1 pour la compatibilité avec des systèmes existants basés sur la spécification originale → Générateur CUID - 8
Si tu dois reproduire le même ID de manière déterministe à partir d'un espace de noms et d'un nom → Générateur UUID v3 - 9
Si tu travailles avec des systèmes DCE ou POSIX hérités qui nécessitent des identifiants v2 → Générateur UUID v2 - 10
Si tu as un UUID existant et veux inspecter sa version, sa variante ou son horodatage → Décodeur UUID
UUID v7 et ULID fournissent tous deux des préfixes d'horodatage avec une précision à la milliseconde et une triabilité lexicographique. La différence clé : UUID v7 utilise le format UUID standard (8-4-4-4-12, 36 caractères) pour une compatibilité maximale avec l'écosystème, tandis que ULID utilise un encodage Base32 personnalisé (26 caractères, sécurisé pour URL, sans tirets). Si ta base de données, ton ORM ou ton framework supporte nativement les colonnes UUID, préfère UUID v7. Si tu as besoin d'IDs plus courts sans contraintes de framework, ULID est plus compact.
Questions fréquentes
Qu'est-ce qu'un UUID ?
Un UUID (Identifiant Universel Unique) est une valeur de 128 bits standardisée dans la RFC 9562. Il s'écrit comme 32 chiffres hexadécimaux en cinq groupes séparés par des tirets : xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx. Le standard définit plusieurs versions avec différentes stratégies d'unicité — aléatoire (v4), basé sur l'horodatage (v1, v7), ou déterministe basé sur le nom (v3, v5).
Quelle est la différence entre UUID v4 et UUID v7 ?
UUID v4 remplit les 122 bits non fixes avec des données aléatoires issues d'une source cryptographiquement sécurisée. UUID v7 encode un horodatage Unix de 48 bits en millisecondes dans les 48 premiers bits, suivi de bits aléatoires. Résultat : les UUID v7 se trient chronologiquement comme de simples chaînes, ce qui maintient les index B-tree de la base de données ordonnés lors des insertions. UUID v7 a été ajouté dans la RFC 9562 (avril 2024) et est le choix privilégié pour les nouvelles clés primaires de base de données.
Les valeurs UUID v4 sont-elles cryptographiquement sécurisées ?
Les valeurs UUID v4 sont générées à l'aide d'un générateur de nombres pseudo-aléatoires cryptographiquement sécurisé (CSPRNG). Elles conviennent comme tokens non devinables — IDs de session, liens de réinitialisation de mot de passe et similaires. Cependant, un UUID n'est pas un secret en lui-même : il n'a pas de HMAC, pas d'expiration, et pas de liaison à un utilisateur spécifique. Traite les UUID comme des identifiants opaques, pas comme des identifiants d'authentification.
Deux systèmes différents peuvent-ils générer le même UUID ?
La probabilité de collision pour UUID v4 est d'environ 1 pour 2^122 par paire. Pour avoir 50% de chance d'une collision quelconque, il faudrait générer environ 2,7 × 10^18 UUIDs — bien au-delà de ce que tout système réel produit. UUID v1 et v7 intègrent en plus un horodatage et/ou des bits aléatoires, rendant la collision accidentelle encore moins probable. Pour tout usage pratique, les UUIDs de systèmes séparés ne se heurteront pas.
Pourquoi les UUID font-ils 36 caractères ?
Un UUID représente 128 bits = 16 octets. Encodé en hexadécimal, cela donne 32 caractères. Le format UUID ajoute 4 tirets à des positions fixes (après des groupes de 8, 4, 4 et 4 chiffres hexadécimaux) pour améliorer la lisibilité et rendre les bits de version et de variante faciles à repérer visuellement, produisant 36 caractères au total. Les tirets ne portent aucune donnée.
Qu'est-ce qu'un ULID et en quoi diffère-t-il d'un UUID ?
ULID (Identifiant Triable Lexicographiquement Universel) est un identifiant de 128 bits encodé en Crockford Base32 (26 caractères, insensible à la casse, sans tirets). Les 48 premiers bits encodent le temps Unix en millisecondes ; les 80 bits restants sont aléatoires. Les ULIDs se trient correctement comme de simples chaînes et sont plus compacts que les UUIDs. Ils ne font pas partie de la RFC UUID — ils utilisent un encodage différent et manquent des champs de version/variante des UUIDs.
Faut-il utiliser des UUIDs ou des entiers auto-incrémentés comme clés primaires ?
Les entiers auto-incrémentés sont séquentiels, compacts et efficaces pour les index, mais nécessitent un coordinateur central (la base de données) pour les attribuer — ce qui échoue dans les systèmes distribués et révèle le nombre de lignes. Les UUIDs (surtout v7 ou ULID) peuvent être générés côté client sans aller-retour vers la base de données, permettant des insertions optimistes et des écritures distribuées. Le compromis est le stockage (16 octets vs. 4–8 octets) et une localité d'index légèrement moindre pour les UUIDs aléatoires (v4). UUID v7 et ULID éliminent le problème de localité d'index grâce aux préfixes d'horodatage.
Quelle est la différence entre UUID v3 et UUID v5 ?
UUID v3 et v5 sont tous deux déterministes : ils produisent toujours le même UUID pour la même paire espace de noms + nom, ce qui les rend utiles pour générer des IDs reproductibles pour des choses comme les entrées DNS, les URLs ou les identifiants d'objets. La seule différence est l'algorithme de hachage : v3 utilise MD5 (128 bits, hérité), v5 utilise SHA-1 (160 bits, tronqué à 128 bits). Préfère UUID v5 pour les nouveaux projets — SHA-1 est plus fort que MD5, même si aucune version n'est utilisée comme hash cryptographique.