UUID vs NanoID
Les deux génèrent des identifiants qui restent uniques sans autorité centrale. Les UUID sont la norme : 36 caractères, RFC 9562, intégrés à chaque runtime et à chaque base de données. Les NanoID sont l’alternative compacte — 21 caractères compatibles URL portant une entropie comparable. Par défaut, les UUID pour les clés et l’infrastructure ; NanoID quand l’identifiant apparaît dans des URL.
UUID vs NanoID en clair
Tout système distribué a besoin d’identifiants que deux machines peuvent créer au même moment sans se consulter. Les UUID ont résolu cela dans les années 1980, normalisés sous RFC 4122 puis révisés en 2024 en RFC 9562 ; NanoID est arrivé en 2017 comme une bibliothèque minimale pourchassant des chaînes plus courtes. Les deux sont à l’épreuve des collisions par les mêmes mathématiques — beaucoup de bits aléatoires — et aucun ne nécessite de serveur de coordination.
Un UUID est 128 bits rendus en 36 caractères : 32 chiffres hexadécimaux dans le motif 8-4-4-4-12, dont six dépensés pour les marqueurs de version et de variante, si bien que la version 4 porte 122 bits aléatoires. Un NanoID par défaut compte 21 caractères tirés de A-Za-z0-9_- — 64 symboles de 6 bits chacun, 126 bits aléatoires, via crypto.getRandomValues. Formes différentes, même plateau de collisions.
Les vraies différences sont opérationnelles : qui peut produire et valider chaque forme, comment les identifiants se comportent dans les index de base de données, leur allure dans une URL, et à quel point le choix est réversible — le tout mesuré ci-dessous, avec un générateur local relié tout au long de la page pour comparer des sorties réelles.
Envie de voir les deux formes en sortie réelle ? Le générateur UUID s’exécute entièrement dans votre navigateur — crypto.getRandomValues, aucun appel réseau, rien n’est consigné.
Pour le tour complet de ce que chaque version encode, le guide des versions UUID passe en revue les versions v1 à v8 avec des exemples détaillés.
Anatomie : ce que contient chaque identifiant
Les UUID encodent leurs propres métadonnées. Les bits 48–51 portent la version — 1 pour temps plus MAC, 4 pour aléatoire, 7 pour aléatoire ordonné dans le temps — et deux bits de plus fixent la variante. Un v4 a toujours l’air aléatoire ; un v7 commence par un horodatage lisible, car ses 48 premiers bits sont des millisecondes depuis l’époque Unix et les UUID frappés le même jour partagent un préfixe.
Les NanoID ne portent aucune métadonnée. Chaque caractère est un tirage indépendant dans l’alphabet, choisi par masquage et échantillonnage par rejet au-dessus de crypto.getRandomValues, si bien que chaque symbole reste uniformément probable. Cette pureté explique pourquoi le format se plie à tout — changez l’alphabet ou la longueur, gardez l’algorithme — et pourquoi un NanoID ne révèle rien sur le moment où il a été créé.
| Aspect | UUID | NanoID |
|---|---|---|
| Spécification directrice | RFC 9562 (2024, ex-RFC 4122) | Convention de bibliothèque (nanoid) — aucune RFC |
| Taille par défaut | 36 caractères, 128 bits | 21 caractères, 126 bits |
| Alphabet | 0-9a-f plus 4 tirets | A-Za-z0-9_- (64 symboles) |
| Source d’aléa | CSPRNG ; crypto.randomUUID() | crypto.getRandomValues avec masquage |
| Horodatage embarqué | v1 et v7 oui ; v4 aucun | Aucun — opaque de par sa conception |
| Entropie utile | 122 bits (v4) ; 74 bits aléatoires en v7 | 126 bits à 21 caractères |
Maths des collisions : pourquoi aucun des deux ne collisionne jamais
La borne d’anniversaire dit qu’un identifiant aléatoire de n bits atteint une probabilité de collision de 50 % autour de 2^(n/2) tirages. Pour l’UUID v4, c’est environ 2^61 — à peu près 2.3 milliards de milliards d’identifiants — avant même que la probabilité d’un seul doublon n’atteigne une chance sur deux ; les 126 bits de NanoID repoussent la barre un peu plus loin. En pratique, les deux sont des systèmes où cela n’arrive jamais — tout doublon que vous rencontrez est un bug de code, pas un événement d’entropie.
Cette équivalence explique pourquoi le débat sur la taille compte moins qu’on ne le croit : 21 caractères NanoID ne sont pas plus sûrs qu’un UUID v4 — la même garantie en moins d’octets. Les raisons honnêtes de choisir relèvent de l’adéquation opérationnelle — stockage, URL, outillage — pas du risque de collision.
Bases de données : le problème de localité d’index
Insérez une clé aléatoire dans un index B-tree et la ligne peut atterrir sur n’importe quelle page ; remplissez les pages à moitié dans un ordre aléatoire et chaque insertion risque une scission de page, des écritures supplémentaires et un cache plus froid. C’est la taxe de fragmentation que paient aussi bien l’UUID v4 que NanoID — NanoID inclus, car il est tout aussi aléatoire. Sur une clé primaire indexée à forte charge d’écriture, ni l’un ni l’autre n’est adapté aux index par défaut.
L’UUID v7 est le remède livré dans la norme elle-même : ses 48 bits de tête sont un horodatage en millisecondes, si bien que les nouvelles clés se trient presque toujours vers le bord droit de l’index. NanoID ne peut pas l’offrir : aucune composante temporelle, rien à trier. Dans une colonne indexée, le vrai choix est v7 contre tout le reste.
- v4 et NanoID dispersent les insertions dans l’arbre — scissions de pages et échecs de cache à grande échelle.
- Le type uuid de Postgres stocke 16 octets bruts ; une clé texte de 36 caractères en stocke 37 ou plus.
- L’avantage texte de NanoID — 21 caractères contre 36 — ne tient que tant que l’alphabet reste documenté.
URL, alphabets et curseur de longueur
L’alphabet de NanoID est compatible URL par construction : A-Za-z0-9_- n’exige aucun encodage pourcentage nulle part dans une URL, donc un identifiant peut être un segment de chemin, une valeur de requête ou un slug sans aucun échappement. Les UUID sont techniquement compatibles URL aussi — chiffres hexadécimaux et tirets ne demandent jamais d’encodage — mais 36 caractères font une chaîne visible bien longue pour un lien.
L’alphabet personnalisé est la caractéristique la plus pratique de NanoID : codes numériques uniquement, liens courts en minuscules — échangez les 64 symboles, gardez l’algorithme. Respectez la règle selon laquelle l’entropie vaut la longueur multipliée par le log2 de la taille de l’alphabet : un NanoID en minuscules de 8 caractères vaut environ 38 bits, acceptable pour un code d’une heure, imprudent comme clé primaire. Les UUID n’offrent pas ce curseur ; le format est fixé à 128 bits.
Quand choisir l’un ou l’autre
Choisissez les UUID quand l’identifiant vit dans l’infrastructure : clés primaires de base de données (v7), échanges entre équipes et fournisseurs, tout ce qu’un tiers doit valider, partout où une primitive intégrée bat une dépendance. La norme est le produit — chaque langage, ORM et base de données la parle déjà.
Choisissez NanoID quand l’identifiant est visible des utilisateurs : URL courtes, liens d’invitation, noms de fichiers, valeurs de cookies, identifiants de requête dans les logs. La recommandation s’inverse proprement — si vous vous battez sans fin contre la largeur d’un UUID dans une URL, ce lien veut du NanoID ; si vous vous surprenez à réimplémenter NanoID dans un backend dont la base de données pourrait servir des clés nativement, cette colonne veut un UUID v7.
Questions fréquentes
Puis-je générer des UUID ou des NanoID ici sans rien envoyer à un serveur ?
Oui. Le générateur s’exécute dans votre onglet grâce au crypto.getRandomValues du navigateur lui-même, et aucune requête ne quitte la page — la Content-Security-Policy du site bloque les appels sortants. Ouvrez le panneau Network de DevTools pendant une génération et regardez-le rester silencieux. L’aléa vient de votre OS via le navigateur, donc la qualité égale celle d’une génération côté serveur.
Les NanoID sont-ils aussi sûrs que l’UUID v4 face aux collisions ?
Un peu plus, en bits bruts : 126 contre 122 pour le v4. Le point de collision à 50 % se situe un peu au-delà de 2^61 tirages (environ 2.3 milliards de milliards d’identifiants pour le v4), bien au-delà de tout volume réaliste. L’écart ne devient pensable que si vous réduisez la longueur ou l’alphabet de NanoID.
Dois-je utiliser NanoID comme clé primaire de base de données ?
Vous pouvez — mais une clé texte de 21 caractères est tout aussi aléatoire que le v4, donc elle hérite de la même fragmentation B-tree sur les tables à forte écriture. Si les insertions sont intensives, l’UUID v7 — ordonné dans le temps — est le choix adapté aux index. NanoID achète des chaînes plus courtes, pas de la localité d’index.
NanoID est-il une norme comme UUID ?
Non. UUID est la RFC 9562, avec prise en charge native dans chaque langage, le type uuid de Postgres et crypto.randomUUID(). NanoID est une convention de bibliothèque : assez petit pour être réimplémenté en quelques minutes, mais chaque producteur et consommateur doit s’accorder sur l’alphabet et la longueur, et rien ne valide la conformité. Cet accord est le prix des 15 caractères économisés.
Pourquoi l’UUID v7 est-il recommandé plutôt que le v1 ?
Le champ node du v1 porte l’adresse MAC de la machine, ce qui fuit l’identité matérielle et relie des identifiants entre systèmes, et son horodatage grégorien en pas de 100 nanosecondes se trie maladroitement face à l’outillage en temps Unix. Le v7 remplace les deux par 48 bits de millisecondes Unix plus des bits aléatoires : triable dans le temps, neutre pour la confidentialité, même RFC. Commencez les nouvelles conceptions en v7 ou en v4.
Quelle longueur minimale pour un NanoID avant que les collisions n’aient d’importance ?
L’entropie vaut le nombre de caractères multiplié par le log2 de la taille de l’alphabet ; divisez l’exposant par deux pour la borne d’anniversaire. Les 21 caractères par défaut font 126 bits. Douze caractères font 72 bits, soit environ 2^36 tirages avant un pile ou face — acceptable par utilisateur, maigre pour une table globale. Huit fait environ 48 bits : des codes à durée de vie courte, jamais des clés primaires.
Où puis-je lire les normes citées ici ?
Quels outils liés devriez-vous utiliser ensuite ?
- Générer un UUIDGénère v4, v7 et v1 en lot et analyse les UUID existantsOuvrir
- Versions d’UUIDGuide en langage clairOuvrir
- GénérateursIdentifiants, texte de remplissage et codes.Ouvrir
- Comment fonctionne Base64Guide en langage clairOuvrir
- JWT vs sessionsComparatif point par pointOuvrir
- Formater du JSONIndente, trie les clés et supprime les commentairesOuvrir