Générer un UUID v4 en JavaScript — Guide

Toute application JavaScript a tôt ou tard besoin d'identifiants uniques — jetons de session, lignes de base de données, clés d'idempotence pour les API de paiement, ID de corrélation pour le tracing distribué. La façon la plus simple de générer un UUID v4 en JavaScript aujourd'hui est crypto.randomUUID() : zéro dépendance, une ligne, cryptographiquement sécurisé. UUID v4 est largement utilisé précisément parce qu'il ne nécessite aucune coordination entre les services — client et serveur peuvent tous deux produire des ID indépendamment sans risque de collision. Ce guide couvre cette API native, le paquet npm uuid, la validation — tout cela sur Node.js 19+ et les navigateurs modernes. Pour une option sans code, le générateur UUID v4 sur ToolDeck produit des identifiants conformes instantanément.

Qu'est-ce que UUID v4 ?

Un UUID (Universally Unique Identifier) version 4 est un identifiant aléatoire de 128 bits formaté en 32 chiffres hexadécimaux séparés par quatre tirets : xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx. Le 4 à la position 15 marque la version. Le caractère y à la position 20 est l'un des suivants : 8, 9, a, ou b (la variante RFC 4122). Les 122 bits restants sont aléatoires. UUID v4 est la version la plus courante dans les applications JavaScript car elle ne nécessite aucune coordination entre les systèmes — vous pouvez générer des ID indépendamment côté client et serveur sans vous soucier des collisions.

// Sans identifiant
const event = { action: "user.login", ts: 1711824000 };

// Avec UUID v4
const event = {
  id: "9b1deb4d-3b7d-4bad-9bdd-2b0d7b3dcb6d",
  action: "user.login",
  ts: 1711824000
};

crypto.randomUUID() — L'approche native JavaScript

crypto.randomUUID() est disponible dans Chrome 92+, Firefox 95+, Safari 15.4+ et Node.js 19+ (avec un support expérimental depuis Node.js 14.17.0 via globalThis.crypto). Il retourne une chaîne UUID v4 en minuscules de 36 caractères. Aucun import n'est nécessaire en JavaScript navigateur. Dans Node.js, vous pouvez l'appeler directement sur l'objet global cryptoou l'importer explicitement depuis le module node:crypto.

// Fonctionne dans tout navigateur moderne — sans étape de build, sans bundler
const requestId = crypto.randomUUID();
console.log(requestId);
// "3e7f1a92-4b0c-4d8e-9f12-7a6b3c8d5e1f"

// Utilisez-le partout où vous avez besoin d'un identifiant unique
const telemetryEvent = {
  event_id: crypto.randomUUID(),
  action: "checkout.started",
  session_id: crypto.randomUUID(),
  timestamp: Date.now(),
  cart_total_cents: 14999,
};
console.log(JSON.stringify(telemetryEvent, null, 2));

// Approche 1 : crypto global (Node.js 19+)
const orderId = crypto.randomUUID();
console.log(orderId);
// "a1b2c3d4-e5f6-4a7b-8c9d-0e1f2a3b4c5d"

// Approche 2 : import explicite depuis node:crypto
import { randomUUID } from 'node:crypto';
const correlationId = randomUUID();
console.log(correlationId);
// "f7e6d5c4-b3a2-4190-8f7e-6d5c4b3a2190"

Détecter la disponibilité de crypto.randomUUID est utile si votre code peut s'exécuter dans des navigateurs plus anciens ou des WebViews embarquées. La vérification se fait avec un simple guard typeof :

function generateUUIDv4() {
  // Préférer l'API native quand elle est disponible
  if (typeof crypto !== 'undefined' && typeof crypto.randomUUID === 'function') {
    return crypto.randomUUID();
  }

  // Fallback manuel avec getRandomValues (voir section suivante)
  const bytes = new Uint8Array(16);
  crypto.getRandomValues(bytes);

  // Définir la version (4) et la variante (RFC 4122)
  bytes[6] = (bytes[6] & 0x0f) | 0x40; // version 4
  bytes[8] = (bytes[8] & 0x3f) | 0x80; // variante 10xx

  const hex = [...bytes].map(b => b.toString(16).padStart(2, '0'));
  return [
    hex.slice(0, 4).join(''),
    hex.slice(4, 6).join(''),
    hex.slice(6, 8).join(''),
    hex.slice(8, 10).join(''),
    hex.slice(10, 16).join(''),
  ].join('-');
}

console.log(generateUUIDv4());
// "9b2e4f1a-7c3d-4e8f-a5b6-0d2c1e9f8a7b"

Générer un UUID v4 sans bibliothèque

Parfois vous ne pouvez pas vous fier à crypto.randomUUID() — peut-être ciblez-vous une WebView qui supprime l'API crypto, ou vous avez besoin de comprendre ce qui se passe sous le capot. L'approche manuelle utilise crypto.getRandomValues() (disponible depuis IE 11) pour remplir 16 octets avec des données aléatoires, puis applique deux opérations de masque pour définir les champs de version et de variante. Ces deux opérations sont la seule différence entre UUID v4 et une chaîne d'octets purement aléatoire.

function uuidv4Manual() {
  const bytes = new Uint8Array(16);
  crypto.getRandomValues(bytes);

  // Définir la version : bits 12–15 de l'octet 6 = 0100 (version 4)
  bytes[6] = (bytes[6] & 0x0f) | 0x40;

  // Définir la variante : bits 6–7 de l'octet 8 = 10 (RFC 4122)
  bytes[8] = (bytes[8] & 0x3f) | 0x80;

  const hex = [...bytes].map(b => b.toString(16).padStart(2, '0'));

  return (
    hex.slice(0, 4).join('') + '-' +
    hex.slice(4, 6).join('') + '-' +
    hex.slice(6, 8).join('') + '-' +
    hex.slice(8, 10).join('') + '-' +
    hex.slice(10, 16).join('')
  );
}

const traceId = uuidv4Manual();
console.log(traceId);
// "e4d7c2a1-3f9b-48e5-a612-9d8c7b6a5f4e"

// Vérifier qu'il passe la validation UUID v4
const UUID_V4_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
console.log(UUID_V4_RE.test(traceId)); // true

Le paquet npm uuid — Support multi-versions

Le paquet uuid sur npm a été la bibliothèque UUID de référence pour JavaScript bien avant que crypto.randomUUID() n'existe. Il reste pertinent dans trois situations : vous avez besoin de versions UUID autres que v4 (v1, v3, v5, v7), vous ciblez des runtimes antérieurs à Node.js 14.17.0, ou vous souhaitez les fonctions utilitaires validate et parse. Pour un UUID v4 simple sur un runtime moderne, l'API native suffit et je me passerais de la dépendance.

npm install uuid

import { v4 as uuidv4, validate, version } from 'uuid';

// Générer un UUID v4
const paymentId = uuidv4();
console.log(paymentId);
// "1b9d6bcd-bbfd-4b2d-9b5d-ab8dfbbd4bed"

// Valider n'importe quelle chaîne UUID
console.log(validate(paymentId));    // true
console.log(validate("not-a-uuid")); // false

// Détecter la version d'un UUID
console.log(version(paymentId));     // 4

// Générer un lot pour alimenter une base de données de test
const testAccounts = Array.from({ length: 5 }, () => ({
  account_id: uuidv4(),
  plan: "starter",
  created_at: new Date().toISOString(),
}));
console.log(testAccounts);

Si vous préférez ne pas écrire de code du tout, essayez le générateur UUID v4 — il génère des identifiants v4 conformes RFC 4122 directement dans votre navigateur en un clic.

UUID déterministe — Générer un UUID v5 à partir d'une chaîne

UUID v4 est aléatoire par définition — l'appeler deux fois donne toujours des résultats différents. Parfois vous avez besoin du contraire : la même chaîne d'entrée doit toujours produire le même UUID. C'est ce que fait UUID v5. Il hache un UUID de namespace et une chaîne d'entrée avec SHA-1, puis formate le résultat en UUID. Même namespace + même entrée = même sortie, à chaque fois, sur chaque machine. C'est utile pour dériver des ID stables à partir d'URL, d'adresses e-mail ou de toute chaîne qui identifie déjà une ressource.

import { v5 as uuidv5 } from 'uuid';

// Namespace intégré pour les URL (RFC 4122)
const URL_NAMESPACE = uuidv5.URL;
// "6ba7b811-9dad-11d1-80b4-00c04fd430c8"

// La même URL produit toujours le même UUID
const pageId1 = uuidv5("https://api.warehouse.dev/products/sku-7291", URL_NAMESPACE);
const pageId2 = uuidv5("https://api.warehouse.dev/products/sku-7291", URL_NAMESPACE);
console.log(pageId1 === pageId2); // true
console.log(pageId1);
// "a6e4e1c0-7e23-5d3b-8f14-9c2a1b3d5e7f"

// Namespace personnalisé pour votre application
const APP_NAMESPACE = "f47ac10b-58cc-4372-a567-0e02b2c3d479";
const tenantId = uuidv5("acme-corp", APP_NAMESPACE);
console.log(tenantId);
// "d4735e3a-265b-564e-8f32-7a1b2c3d4e5f"

Note rapide : UUID v3 fait la même chose mais avec MD5 au lieu de SHA-1. Préférez v5 pour les nouveaux projets. MD5 présente des faiblesses de collision connues, et bien que cela importe peu pour la génération d'ID, il n'y a aucune raison de le choisir face à SHA-1 quand les deux sont disponibles.

Référence de crypto.randomUUID() et des API associées

La méthode native crypto.randomUUID() ne prend aucun argument — elle retourne une chaîne et rien d'autre. Utilisez-la lorsque vous avez besoin d'identifiants conformes RFC 4122 sans dépendances. Quand vous avez besoin d'octets aléatoires bruts plutôt que d'une chaîne UUID formatée — par exemple, pour remplir un tableau typé ou dériver une clé — utilisez directement crypto.getRandomValues(). Les API associées qui importent pour le travail avec les UUID sont listées ci-dessous.

Décomposition du motif regex UUID v4 :

Valider un UUID v4 avec une regex

Valider qu'une chaîne est un UUID v4 correct survient constamment — corps de requêtes API entrantes, paramètres d'URL, payloads de webhook. Une regex écrite à la main est le bon choix quand vous souhaitez zéro dépendance et ne validez que du v4. Si vous utilisez déjà le paquet uuid, préférez son export validate() — il gère toutes les versions UUID et est moins sujet aux erreurs que maintenir un motif personnalisé. La regex /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i vérifie à la fois le quartet de version (doit être 4) et le quartet de variante (doit être 8, 9, a, ou b). Utilisez RegExp.prototype.test() pour les vérifications booléennes et .match() lorsque vous devez extraire un UUID d'un texte environnant.

const UUID_V4_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;

function isUUIDv4(str) {
  return UUID_V4_RE.test(str);
}

// UUID v4 valide
console.log(isUUIDv4("9b1deb4d-3b7d-4bad-9bdd-2b0d7b3dcb6d")); // true

// UUID v1 — le quartet de version est 1, pas 4
console.log(isUUIDv4("550e8400-e29b-11d4-a716-446655440000")); // false

// UUID v7 — le quartet de version est 7
console.log(isUUIDv4("018e4a0c-5b3f-7d12-8a9b-0c1d2e3f4a5b")); // false

// Chaînes malformées
console.log(isUUIDv4("not-a-uuid"));           // false
console.log(isUUIDv4(""));                      // false
console.log(isUUIDv4("9b1deb4d3b7d4bad9bdd2b0d7b3dcb6d")); // false (sans tirets)

// Extraire un UUID d'une chaîne plus grande
const logLine = 'Request req_id=9b1deb4d-3b7d-4bad-9bdd-2b0d7b3dcb6d failed with 503';
const match = logLine.match(/[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}/i);
console.log(match?.[0]);
// "9b1deb4d-3b7d-4bad-9bdd-2b0d7b3dcb6d"

Générer et attacher des UUID depuis un fichier et une réponse API

En pratique, vous appelez rarement crypto.randomUUID() de manière isolée. Deux patterns reviennent constamment : assigner des ID aux enregistrements avant de les écrire dans une base de données, et attacher des ID de corrélation aux requêtes API sortantes pour pouvoir tracer une requête à travers les services dans vos journaux.

Lire un fichier NDJSON → Assigner des UUID → Réécrire

import { readFileSync, writeFileSync } from 'node:fs';
import { randomUUID } from 'node:crypto';

function assignIds(inputPath, outputPath) {
  const lines = readFileSync(inputPath, 'utf-8')
    .split('\n')
    .filter(line => line.trim());

  const records = lines.map(line => {
    try {
      const record = JSON.parse(line);
      if (!record.id) {
        record.id = randomUUID();
      }
      return JSON.stringify(record);
    } catch (err) {
      console.error(`Skipping malformed line: ${err.message}`);
      return null;
    }
  }).filter(Boolean);

  writeFileSync(outputPath, records.join('\n') + '\n');
  console.log(`Assigned IDs to ${records.length} records → ${outputPath}`);
}

assignIds('warehouse-products.ndjson', 'warehouse-products-with-ids.ndjson');
// Assigned IDs to 1284 records → warehouse-products-with-ids.ndjson

Attacher un ID de corrélation à une requête API sortante

import { randomUUID } from 'node:crypto';

async function createShipment(orderPayload) {
  const correlationId = randomUUID();

  try {
    const response = await fetch('https://api.logistics.dev/v2/shipments', {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'X-Correlation-ID': correlationId,
        'X-Idempotency-Key': randomUUID(),
      },
      body: JSON.stringify(orderPayload),
    });

    if (!response.ok) {
      const errorBody = await response.text();
      throw new Error(`Shipment API returned ${response.status}: ${errorBody}`);
    }

    const result = await response.json();
    console.log(`Shipment created: ${result.shipment_id} (correlation: ${correlationId})`);
    return result;
  } catch (err) {
    console.error(`[correlation:${correlationId}] Shipment failed: ${err.message}`);
    throw err;
  }
}

await createShipment({
  order_id: "ord_8a3f91bc",
  destination: { city: "Paris", state: "IDF", zip: "75001" },
  items: [{ sku: "WH-7291", quantity: 2, weight_kg: 1.4 }],
});

Génération d'UUID en ligne de commande

Vous n'avez pas toujours besoin d'un script. Node.js peut générer un UUID directement depuis la ligne de commande, ce qui est pratique pour les scripts shell, les pipelines CI et les tests ad hoc rapides. Le drapeau -eévalue une expression unique.

# Un seul UUID
node -e "console.log(crypto.randomUUID())"
# 3e7f1a92-4b0c-4d8e-9f12-7a6b3c8d5e1f

# Cinq UUID d'un coup
node -e "for(let i=0;i<5;i++) console.log(crypto.randomUUID())"

# Générer et assigner à une variable shell
export REQUEST_ID=$(node -e "process.stdout.write(crypto.randomUUID())")
echo "Request ID: $REQUEST_ID"

# Utiliser npx uuid (si le paquet est installé globalement ou pour un usage ponctuel)
npx uuid v4
# 1b9d6bcd-bbfd-4b2d-9b5d-ab8dfbbd4bed

# Ouvrez la console DevTools de n'importe quel navigateur et tapez :
crypto.randomUUID()
# "9b1deb4d-3b7d-4bad-9bdd-2b0d7b3dcb6d"

Alternative haute performance — nanoid

Si vous générez des milliers d'ID par seconde et que le format UUID de 36 caractères n'est pas une exigence absolue, envisagez nanoid. Il est 2x plus rapide que uuid.v4(), produit un ID URL-safe de 21 caractères par défaut, et pèse environ 1 Ko après minification. La sortie n'est pas un UUID — c'est un ID à alphabet personnalisé — donc ne l'utilisez pas là où la conformité RFC 4122 est requise (colonnes UUID de base de données, API qui valident le format UUID, identifiants de trace OpenTelemetry). Mais pour les ID de corrélation internes, les clés de composants React et les slugs d'URL, c'est un bon choix.

npm install nanoid

import { nanoid, customAlphabet } from 'nanoid';

// Par défaut : ID URL-safe de 21 chars (A-Za-z0-9_-)
const trackingCode = nanoid();
console.log(trackingCode);
// "V1StGXR8_Z5jdHi6B-myT"

// Longueur personnalisée
const shortCode = nanoid(10);
console.log(shortCode);
// "IRFa-VaY2b"

// Alphabet personnalisé — chiffres uniquement, 12 digits
const numericId = customAlphabet('0123456789', 12);
console.log(numericId());
// "839274651023"

// Alphabet personnalisé — hex uniquement, 32 chars (même entropie que UUID v4 sans tirets)
const hexId = customAlphabet('0123456789abcdef', 32);
console.log(hexId());
// "4f8a1b2c3d7e9f0a5b6c8d1e2f3a4b5c"

Sortie terminal avec coloration syntaxique

Déboguer des applications intensives en UUID signifie fixer des murs de chaînes hex dans le terminal. La mise en couleur aide. La bibliothèque chalk (ou le plus récent node:util styleText intégré dans Node.js 21.7+) vous permet de mettre en évidence les UUID dans la sortie de log pour qu'ils ressortent du texte environnant.

import chalk from 'chalk';
import { randomUUID } from 'node:crypto';

function logEvent(action, metadata = {}) {
  const eventId = randomUUID();
  const timestamp = new Date().toISOString();

  console.log(
    chalk.gray(timestamp),
    chalk.cyan(eventId),
    chalk.white(action),
    Object.keys(metadata).length
      ? chalk.dim(JSON.stringify(metadata))
      : ''
  );
}

logEvent('shipment.created', { order_id: 'ord_8a3f', carrier: 'fedex' });
logEvent('payment.captured', { amount_cents: 14999, currency: 'USD' });
logEvent('webhook.delivered', { endpoint: 'https://hooks.acme.dev/orders' });
// 2026-03-27T10:15:00.000Z  a1b2c3d4-...  shipment.created  {"order_id":"ord_8a3f",...}

Générer des identifiants uniques courts en JavaScript

Un UUID de 36 caractères est parfois trop long — les slugs d'URL, les données de QR code, les SMS et les protocoles matériels embarqués ont tous des contraintes de longueur.

import { randomUUID } from 'node:crypto';

// 1. Supprimer les tirets de UUID v4 → chaîne hex de 32 chars
const hex32 = randomUUID().replaceAll('-', '');
console.log(hex32);
// "3e7f1a924b0c4d8e9f127a6b3c8d5e1f" (32 chars)

// 2. Encoder en Base64 16 octets aléatoires → chaîne de 22 chars (URL-safe)
const bytes = new Uint8Array(16);
crypto.getRandomValues(bytes);
const base64Id = Buffer.from(bytes)
  .toString('base64url')
  .replace(/=+$/, '');
console.log(base64Id);
// "Pj8akksNTY6fEnarPIvR" (22 chars, 128 bits d'entropie)

// 3. nanoid avec longueur personnalisée
import { nanoid } from 'nanoid';
const short12 = nanoid(12);
console.log(short12);
// "V1StGXR8_Z5j" (12 chars, ~71 bits d'entropie)

Le calcul de probabilité de collision : un nanoid de 12 caractères (alphabet par défaut de 64 caractères) donne environ 71 bits d'entropie. À 1 000 ID par seconde, il vous faudrait environ 116 ans pour atteindre une probabilité de collision de 1 %. Pour la plupart des applications, c'est plus que suffisant. Si vous générez des millions d'ID par jour, restez avec l'UUID complet ou utilisez nanoid avec au moins 21 caractères.

UUID v7 — Alternative ordonnée par temps à v4

UUID v7 (défini dans RFC 9562) intègre un horodatage Unix en millisecondes sur 48 bits dans le premier segment, suivi de bits aléatoires. Le résultat est un UUID qui ressemble à v4 mais se trie chronologiquement. Cela en fait un meilleur choix que v4 pour les clés primaires de base de données : les nouvelles lignes atterrissent toujours en fin d'index B-tree au lieu de positions aléatoires, ce qui réduit les fractionnements de pages et la fragmentation. Dans les projets où j'ai besoin d'ID ordonnés par temps pour une table Postgres, je passe à v7 immédiatement — la différence de performance sur les index est mesurable à l'échelle. Le générateur UUID v7 sur ToolDeck affiche l'horodatage intégré pour tout UUID v7.

import { v7 as uuidv7 } from 'uuid';

// Générer trois valeurs UUID v7 — notez qu'elles se trient chronologiquement
const id1 = uuidv7();
const id2 = uuidv7();
const id3 = uuidv7();

console.log(id1);
// "018e4a0c-5b3f-7d12-8a9b-0c1d2e3f4a5b"
console.log(id2);
// "018e4a0c-5b40-7e34-9c2d-1e4f5a6b7c8d"
console.log(id3);
// "018e4a0c-5b41-7f56-ae3f-2a5b6c7d8e9f"

// Ils se trient lexicographiquement par heure de création
console.log([id3, id1, id2].sort());
// [id1, id2, id3] — ordre chronologique préservé

// Utilisez v4 pour les jetons où le timing ne doit pas être divulgué
import { v4 as uuidv4 } from 'uuid';
const sessionToken = uuidv4(); // totalement aléatoire, aucune info de timing

UUID v4 dans le navigateur sans étape de build

Sans bundler, sans npm, sans transpileur. Juste un simple fichier HTML. C'est la façon la plus simple de générer un UUID en JavaScript côté client. Cela fonctionne parce que crypto.randomUUID() est une API navigateur intégrée.

<!DOCTYPE html>
<html lang="fr">
<head><meta charset="utf-8"><title>Générateur UUID</title></head>
<body>
  <p>Votre UUID : <strong id="output"></strong></p>
  <button onclick="document.getElementById('output').textContent = crypto.randomUUID()">
    Générer
  </button>
  <script>
    // Générer un au chargement de la page
    document.getElementById('output').textContent = crypto.randomUUID();
  </script>
</body>
</html>

C'est tout le fichier. Aucun import CDN, aucune balise script chargeant des bibliothèques. Pour quelque chose de plus complexe — génération en lot, validation, ID déterministes — vous aurez besoin du paquet uuid ou du fallback manuel présenté plus tôt. Mais pour un prototype rapide ou un outil interne, c'est tout ce dont vous avez besoin.

Erreurs courantes

J'ai vu le pattern UUID avec Math.random() copié depuis de vieux articles de blog vers du code de production plus souvent que je ne le souhaiterais. Les bugs que ces patterns introduisent sont silencieux : aucune erreur à l'exécution, juste un comportement subtilement incorrect qui apparaît plus tard sous charge ou lors des audits de sécurité.

// NON SÉCURISÉ — prévisible, faible entropie
function badUuid() {
  return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(
    /[xy]/g,
    c => {
      const r = Math.random() * 16 | 0;
      return (c === 'x' ? r : (r & 0x3 | 0x8)).toString(16);
    }
  );
}

// SÉCURISÉ — utilise le CSPRNG du système d'exploitation
const id = crypto.randomUUID();

// Ou si vous avez besoin d'un fallback manuel :
function secureUuid() {
  const bytes = new Uint8Array(16);
  crypto.getRandomValues(bytes);
  bytes[6] = (bytes[6] & 0x0f) | 0x40;
  bytes[8] = (bytes[8] & 0x3f) | 0x80;
  const h = [...bytes].map(b => b.toString(16).padStart(2, '0'));
  return `${h.slice(0,4).join('')}-${h.slice(4,6).join('')}-${h.slice(6,8).join('')}-${h.slice(8,10).join('')}-${h.slice(10).join('')}`;
}

const fromApi = "9B1DEB4D-3B7D-4BAD-9BDD-2B0D7B3DCB6D"; // majuscules depuis l'API
const local  = "9b1deb4d-3b7d-4bad-9bdd-2b0d7b3dcb6d";  // minuscules depuis crypto

if (fromApi === local) { /* ne s'exécute jamais */ }

const fromApi = "9B1DEB4D-3B7D-4BAD-9BDD-2B0D7B3DCB6D";
const local  = "9b1deb4d-3b7d-4bad-9bdd-2b0d7b3dcb6d";

if (fromApi.toLowerCase() === local.toLowerCase()) {
  // correspond correctement
}

// Création d'un wrapper inutile
class UUID {
  constructor(value) { this.value = value; }
}
const id = new UUID(crypto.randomUUID());
console.log(id === id); // true, mais...
console.log(JSON.stringify({ id })); // {"id":{"value":"..."}}

// Utilisez simplement une chaîne
const id = crypto.randomUUID();
console.log(JSON.stringify({ id }));
// {"id":"3e7f1a92-4b0c-4d8e-9f12-7a6b3c8d5e1f"}

// Mauvais : utiliser v4 comme clé primaire triable
const rows = [
  { id: crypto.randomUUID(), created: "2026-03-27" },
  { id: crypto.randomUUID(), created: "2026-03-26" },
];
rows.sort((a, b) => a.id.localeCompare(b.id));
// L'ordre de tri est aléatoire — PAS par date de création

import { v7 as uuidv7 } from 'uuid';
// Bien : v7 se trie par heure de création
const rows = [
  { id: uuidv7(), created: "2026-03-27" },
  { id: uuidv7(), created: "2026-03-26" },
];
rows.sort((a, b) => a.id.localeCompare(b.id));
// L'ordre de tri correspond à l'heure de création

crypto.randomUUID() vs uuid vs nanoid — Comparaison rapide

Pour la plupart des projets JavaScript : utilisez crypto.randomUUID() quand vous n'avez besoin que d'UUID v4 et que votre runtime est suffisamment récent. Tournez-vous vers le paquet uuid quand vous avez besoin du support v5 (déterministe) ou v7 (ordonné par temps). Utilisez nanoid quand un ID court et URL-safe est plus pratique qu'un UUID de 36 caractères — mais rappelez-vous que la sortie nanoid n'est pas conforme UUID et échouera la validation sur tout système attendant le format RFC 4122.

Pour une alternative sans code, essayez le générateur UUID v4 pour créer des identifiants instantanément dans le navigateur. Pour inspecter un UUID existant, collez-le dans le décodeur UUID pour voir sa version, sa variante et les données d'horodatage éventuellement intégrées.

Foire aux questions

const sessionId = crypto.randomUUID();
console.log(sessionId);
// "3e7f1a92-4b0c-4d8e-9f12-7a6b3c8d5e1f"

// UUID v4 — aléatoire, non triable
const correlationId = crypto.randomUUID();

// UUID v7 — ordonné par temps, meilleur pour les clés primaires DB
import { v7 as uuidv7 } from 'uuid';
const rowId = uuidv7();

const UUID_V4_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;

UUID_V4_RE.test("550e8400-e29b-41d4-a716-446655440000"); // true
UUID_V4_RE.test("550e8400-e29b-11d4-a716-446655440000"); // false (v1)
UUID_V4_RE.test("not-a-uuid"); // false

// Chaîne hex de 32 chars à partir d'UUID v4
const hexId = crypto.randomUUID().replaceAll('-', '');
// "3e7f1a924b0c4d8e9f127a6b3c8d5e1f"

// ID URL-safe de 21 chars via nanoid
import { nanoid } from 'nanoid';
const shortId = nanoid();
// "V1StGXR8_Z5jdHi6B-myT"

Outils associés