uToolGo Utility Tools, Go Further

Générateur d'UUID

Un outil professionnel de génération et de validation d'UUID prenant en charge plusieurs versions, notamment v1 (horodatage), v4 (aléatoire), v5 (basé sur un nom) et v7 (temps Unix + aléatoire). Il propose la génération par lot avec un nombre personnalisable, ainsi que des options de formatage flexibles telles que la conversion en majuscules, la suppression des tirets et l'ajout d'accolades. L'outil inclut un validateur d'UUID intégré avec détection de version et fournit des exemples de code multilingues. Idéal pour l'identification d'enregistrements de base de données, le traçage de logs, les interfaces inter-systèmes et d'autres cas d'utilisation. Toutes les opérations sont effectuées localement dans votre navigateur, garantissant confidentialité et sécurité.

Générateur d'UUID

Options de formatage

Validateur d'UUID

Guide d'utilisation

Les UUID sont des identifiants de 128 bits, généralement représentés sous forme de chaînes de 36 caractères contenant des tirets.
UUID v1 : Basé sur l'horodatage et l'adresse MAC ; ordonné dans le temps mais peut divulguer des informations temporelles ou géolocalisées.
UUID v4 : Généré aléatoirement ; le plus couramment utilisé, offrant une forte unicité et confidentialité.
UUID v7 : Basé sur les millisecondes Unix + bits aléatoires ; naturellement triable et évite les problèmes de confidentialité du v1.
UUID v5 : Généré de manière déterministe à partir d'un UUID de namespace et d'un nom via SHA-1 ; des entrées identiques produisent toujours le même résultat.
Format standard : xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx (36 caractères).

Fonctionnalités

  • Prise en charge des UUID v1, v4, v5 et v7
  • Génération par lots avec nombre personnalisable
  • Mise en forme flexible : majuscules, suppression des tirets, ajout d'accolades
  • Validateur intégré avec détection automatique de la version
  • Internationalisation complète et prise en charge de plusieurs thèmes

Qu'est-ce qu'un UUID ?

Les UUID sont des identifiants de 128 bits, généralement représentés sous forme de chaînes de 36 caractères contenant des tirets.

UUID v1 : Basé sur l'horodatage et l'adresse MAC ; ordonné dans le temps mais peut divulguer des informations temporelles ou géolocalisées.

UUID v4 : Généré aléatoirement ; le plus couramment utilisé, offrant une forte unicité et confidentialité.

UUID v7 : Basé sur les millisecondes Unix + bits aléatoires ; naturellement triable et évite les problèmes de confidentialité du v1.

UUID v5 : Généré de manière déterministe à partir d'un UUID de namespace et d'un nom via SHA-1 ; des entrées identiques produisent toujours le même résultat.

UUID Exemples rapides

Format standard :
550e8400-e29b-41d4-a716-446655440000
Format en majuscules :
550E8400-E29B-41D4-A716-446655440000
Sans tirets :
550e8400e29b41d4a716446655440000
Avec accolades :
{550e8400-e29b-41d4-a716-446655440000}

UUID Cas d'utilisation courants

  • Identifiants uniques pour les enregistrements de base de données ou les ressources
  • IDs de trace pour la journalisation et le suivi des événements
  • Identifiants publics imprévisibles
  • Identifiants cohérents entre les intégrations système

UUID FAQ et pièges à éviter

  • v1 et confidentialité : le v1 peut exposer des horodatages ou l'emplacement matériel ; préférez le v4 pour les cas sensibles à la confidentialité.
  • Sensibilité à la casse : la correspondance des UUID n'est pas sensible à la casse.
  • Les tirets servent uniquement à la lisibilité ; conservez-les sauf contrainte liée aux systèmes hérités.
  • Le format entre accolades (ex. {xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx}) est accepté dans certains environnements (ex. Registre Windows).
  • Le v5 est déterministe : même namespace + même nom => même UUID. Idéal pour les opérations idempotentes ; à éviter lorsque l'imprévisibilité est requise.

Utilisation des UUID dans les langages de programmation

JavaScript
Générer
// UUID v4 (simple)
function uuidv4(){
  return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, c => {
    const r = Math.random()*16|0, v = c === 'x' ? r : (r&0x3|0x8);
    return v.toString(16);
  });
}
const id = uuidv4();
UUID v7 (Temps Unix + Aléatoire)
// UUID v7 (Unix ms + randomness)
function uuidv7(){
  const cryptoObj = (globalThis.crypto || globalThis.msCrypto);
  const rb = n => { const a = new Uint8Array(n); cryptoObj?.getRandomValues ? cryptoObj.getRandomValues(a) : a.forEach((_,i)=>a[i]=Math.random()*256|0); return a; };
  const hex = b => Array.from(b).map(x=>x.toString(16).padStart(2,'0')).join('');
  const ts = BigInt(Date.now()).toString(16).padStart(12,'0');
  const ver = rb(2); ver[0] = (ver[0] & 0x0f) | 0x70;    // set version 7
  const vrn = rb(2); vrn[0] = (vrn[0] & 0x3f) | 0x80;    // RFC4122 variant
  const tail = rb(6);
  return `${ts.slice(0,8)}-${ts.slice(8,12)}-${hex(ver)}-${hex(vrn)}-${hex(tail)}`;
}
const id7 = uuidv7();
Valider
const re=/^[0-9a-f]{8}-[0-9a-f]{4}-[1-57][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
re.test(id); // true/false
PHP
Générer
<?php
// v4 using random_bytes
function uuidv4(){
  $data = random_bytes(16);
  $data[6] = chr((ord($data[6]) & 0x0f) | 0x40);
  $data[8] = chr((ord($data[8]) & 0x3f) | 0x80);
  return vsprintf('%s%s-%s-%s-%s-%s%s%s', str_split(bin2hex($data), 4));
}
$id = uuidv4();
UUID v7 (Temps Unix + Aléatoire)
<?php
// composer require ramsey/uuid:^4.7
use Ramsey\Uuid\Uuid;

$uuid7 = Uuid::uuid7();
Valider
<?php
$re = '/^[0-9a-f]{8}-[0-9a-f]{4}-[1-57][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i';
preg_match($re, $id) === 1; // true/false
Python
Générer
import uuid
# v4
uid = uuid.uuid4()
# v1
uid1 = uuid.uuid1()
UUID v7 (Temps Unix + Aléatoire)
# pip install uuid6
from uuid6 import uuid7

uid7 = uuid7()
Valider
import re
re_uuid = re.compile(r'^[0-9a-f]{8}-[0-9a-f]{4}-[1-57][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$', re.I)
bool(re_uuid.match(str(uid)))
Go
Générer
// go get github.com/google/uuid
import "github.com/google/uuid"

id := uuid.New()     // v4
id1 := uuid.NewUUID() // v1 (may return error)
UUID v7 (Temps Unix + Aléatoire)
// go get github.com/gofrs/uuid/v5
import (
  uuid "github.com/gofrs/uuid/v5"
)

id7, err := uuid.NewV7()
Valider
import "github.com/google/uuid"
_, err := uuid.Parse(id.String()) // err == nil means valid
Rust
Générer
// Cargo.toml: uuid = { version = "1", features = ["v4", "v1"] }
use uuid::Uuid;

let v4 = Uuid::new_v4();
// v1 requires a context/ts, often via external crate; shown for completeness
UUID v7 (Temps Unix + Aléatoire)
// Cargo.toml: uuid = { version = "1", features = ["v7"] }
use uuid::Uuid;

let v7 = Uuid::now_v7();
Valider
use uuid::Uuid;
let ok = Uuid::parse_str(v4.to_string().as_str()).is_ok();
Java
Générer
import java.util.UUID;

UUID id = UUID.randomUUID(); // v4
UUID v7 (Temps Unix + Aléatoire)
// Maven: com.github.f4b6a3:uuid-creator
import com.github.f4b6a3.uuid.UuidCreator;

UUID v7 = UuidCreator.getTimeOrderedEpoch(); // UUIDv7
Valider
import java.util.UUID;

try { UUID.fromString(id.toString()); /* valid */ } catch (IllegalArgumentException ex) { /* invalid */ }
Rechercher des outils →