Générateur UUID

Qu'est-ce qu'un UUID ?

UUID (Universally Unique Identifier, Identifiant unique universel) est un nombre de 128 bits utilisé pour identifier de manière unique les informations dans les systèmes informatiques. UUID est également appelé GUID (Globally Unique Identifier, Identifiant unique global).

Caractéristiques de l'UUID

Unicité : La probabilité de générer des UUID en double dans un système distribué est extrêmement faible
Standardisation : Conforme à la norme RFC 4122
Multi-plateforme : Peut être utilisé sur différents systèmes d'exploitation et langages de programmation
Décentralisé : Ne nécessite pas d'autorité de coordination centrale

Scénarios d'application de l'UUID

Clé primaire de base de données : Utilisé comme clé primaire dans les bases de données distribuées
Identification de fichiers : Identifier les fichiers dans le système de fichiers
Gestion de session : Identifiant de session dans les applications Web
File d'attente de messages : Identifiant unique des messages
Interface API : Identifiant des requêtes et réponses API

Détails des versions UUID

UUID v1 (basé sur le temps et le nœud)

Format : xxxxxxxx-xxxx-1xxx-yxxx-xxxxxxxxxxxx

Caractéristiques :

Basé sur l'heure actuelle et l'ID du nœud (généralement l'adresse MAC)
Contient des informations d'horodatage, peut être trié par temps
Peut révéler des informations d'adresse MAC

Algorithme de génération :

// Exemple de pseudo-code
function generateUUIDv1() {
  const timestamp = Date.now();
  const nodeId = getMACAddress();
  const clockSeq = random16Bit();

  return formatUUID(timestamp, clockSeq, nodeId);
}

UUID v3 (basé sur l'espace de noms et MD5)

Format : xxxxxxxx-xxxx-3xxx-yxxx-xxxxxxxxxxxx

Caractéristiques :

Basé sur le hachage MD5 de l'UUID d'espace de noms et du nom
Le même espace de noms et le même nom produisent toujours le même UUID
Applicable aux scénarios nécessitant des UUID déterministes

Algorithme de génération :

function generateUUIDv3(namespace, name) {
  const namespaceBytes = parseUUID(namespace);
  const nameBytes = Buffer.from(name, 'utf8');
  const hash = crypto
    .createHash('md5')
    .update(Buffer.concat([namespaceBytes, nameBytes]))
    .digest();

  return formatUUIDv3(hash);
}

UUID v4 (génération aléatoire)

Format : xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx

Caractéristiques :

Génération complètement aléatoire
Version UUID la plus couramment utilisée
Ne contient aucune information significative

Algorithme de génération :

function generateUUIDv4() {
  const bytes = crypto.randomBytes(16);
  bytes[6] = (bytes[6] & 0x0f) | 0x40; // Version 4
  bytes[8] = (bytes[8] & 0x3f) | 0x80; // Variante

  return formatUUID(bytes);
}

UUID v5 (basé sur l'espace de noms et SHA-1)

Format : xxxxxxxx-xxxx-5xxx-yxxx-xxxxxxxxxxxx

Caractéristiques :

Basé sur le hachage SHA-1 de l'UUID d'espace de noms et du nom
Plus sûr que v3 (utilise SHA-1 au lieu de MD5)
Applicable aux scénarios nécessitant des UUID déterministes

UUID NIL (UUID vide)

Format : 00000000-0000-0000-0000-000000000000

Caractéristiques :

Tous les bits sont 0
Utilisé pour représenter "aucun UUID" ou "UUID inconnu"
Utilisé comme valeur par défaut dans la conception de base de données

Espaces de noms prédéfinis

UUID d'espace de noms standard

Espace de noms DNS : 6ba7b810-9dad-11d1-80b4-00c04fd430c8
Espace de noms URL : 6ba7b811-9dad-11d1-80b4-00c04fd430c8
Espace de noms OID : 6ba7b812-9dad-11d1-80b4-00c04fd430c8
Espace de noms X.500 DN : 6ba7b814-9dad-11d1-80b4-00c04fd430c8

Exemple d'utilisation

// Générer UUID v3 en utilisant l'espace de noms DNS
const dnsNamespace = '6ba7b810-9dad-11d1-80b4-00c04fd430c8';
const uuid = generateUUIDv3(dnsNamespace, 'example.com');
// Résultat : 5df41881-3aed-3515-88a7-2f4a814cf09e

Interface API

Génération d'UUID unique

// Générer UUID v4
const uuid = generateUUID('v4');

// Générer UUID v1
const uuid = generateUUID('v1');

// Générer UUID v3
const uuid = generateUUID('v3', {
  namespace: '6ba7b810-9dad-11d1-80b4-00c04fd430c8',
  name: 'example.com',
});

Génération d'UUID par lot

// Génération d'UUID par lot
const uuids = generateMultipleUUIDs('v4', 10);

// Générer des UUID de différentes versions
const mixedUUIDs = generateMultipleUUIDs(['v1', 'v4', 'v5'], 5);

Validation UUID

// Valider le format UUID
const isValid = validateUUID('550e8400-e29b-41d4-a716-446655440000');

// Obtenir la version UUID
const version = getUUIDVersion('550e8400-e29b-41d4-a716-446655440000');

Considérations de performance

Vitesse de génération

v4 (aléatoire) : Plus rapide, environ 100 000 UUID/seconde
v1 (temps) : Moyen, environ 50 000 UUID/seconde
v3/v5 (hachage) : Plus lent, environ 10 000 UUID/seconde

Utilisation de la mémoire

Chaque UUID occupe 16 octets
Attention à l'utilisation de la mémoire lors de la génération par lot

Sécurité concurrentielle

v4 utilise un générateur de nombres aléatoires cryptographiquement sûr
v1 nécessite d'assurer l'unicité de la séquence d'horloge

Meilleures pratiques

Choix de la version UUID

Usage général : Utiliser UUID v4
Tri temporel nécessaire : Utiliser UUID v1
Déterminisme nécessaire : Utiliser UUID v3 ou v5
Clé primaire de base de données : Recommander UUID v4

Optimisation du stockage

-- Stockage UUID dans PostgreSQL
CREATE TABLE users (
  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
  name VARCHAR(255)
);

-- Créer un index
CREATE INDEX idx_users_id ON users(id);

Optimisation des performances

// Utiliser un pool d'objets pour réduire l'allocation de mémoire
const uuidPool = new Array(1000).fill(null).map(() => generateUUIDv4());

// Utiliser Web Workers pour la génération par lot
const worker = new Worker('uuid-worker.js');
worker.postMessage({ type: 'generate', count: 1000 });