UUID Generator: Guida Completa agli Identificatori Univoci

Cos'è un UUID

UUID (Universally Unique Identifier) è uno standard per generare identificatori univoci senza coordinazione centrale. Con 128 bit di entropia, la probabilità di collisione è così bassa da essere trascurabile. Gli UUID sono fondamentali per sistemi distribuiti, database, API e qualsiasi scenario dove serve un ID univoco generabile ovunque. Questa guida copre versioni, implementazioni e best practices.

Formato UUID

Struttura Standard

# Formato canonico (RFC 4122)
xxxxxxxx-xxxx-Mxxx-Nxxx-xxxxxxxxxxxx

# M = versione (1-7)
# N = variante (8, 9, a, b)

# Esempio UUIDv4
550e8400-e29b-41d4-a716-446655440000
        │    │    │
        │    │    └── Variante (a = RFC 4122)
        │    └─────── Versione (4 = random)
        └──────────── Gruppi separati da trattini

# 32 caratteri hex + 4 trattini = 36 caratteri
# 128 bit = 16 byte

Rappresentazioni

# Standard (con trattini)
550e8400-e29b-41d4-a716-446655440000

# Senza trattini
550e8400e29b41d4a716446655440000

# URN
urn:uuid:550e8400-e29b-41d4-a716-446655440000

# Base64 (22 caratteri)
VQ6EAOKbQdSnFkRmVUQAAA==

# Binary (16 byte)
0x550e8400e29b41d4a716446655440000

Versioni UUID

UUIDv1 (Timestamp + MAC)

# Struttura: timestamp + clock sequence + MAC address
6ba7b810-9dad-11d1-80b4-00c04fd430c8
        │         │
        │         └── MAC address (ultimi 12 caratteri)
        └──────────── Timestamp embedded

# Pro:
# - Ordinabile per tempo di creazione
# - Unicità garantita (MAC è unico)

# Contro:
# - Espone MAC address (privacy)
# - Espone timestamp (sicurezza)
# - Richiede accesso a MAC

# Uso: sistemi chiusi dove privacy non è problema

UUIDv4 (Random)

# Il più usato: 122 bit random
f47ac10b-58cc-4372-a567-0e02b2c3d479

# Come viene generato:
# 1. Genera 128 bit random
# 2. Imposta version bits (4 = 0100)
# 3. Imposta variant bits (10xx)

# Pro:
# - Semplice da generare
# - Sicuro (non espone info)
# - Imprevedibile

# Contro:
# - Non ordinabile
# - Frammentazione indice database
# - Richiede buon RNG

# Uso: API, database, session token

UUIDv7 (Timestamp + Random)

# Nuovo standard (2024): timestamp Unix ms + random
018e5f9c-7c00-7000-8000-000000000001
│          │
│          └── 7 = versione 7
└──────────── Timestamp (primi 48 bit)

# Come viene generato:
# 1. Primi 48 bit = timestamp Unix ms
# 2. 4 bit version = 7
# 3. 12 bit random
# 4. 2 bit variant
# 5. 62 bit random

# Pro:
# - Ordinabile cronologicamente
# - Buone performance indice (quasi sequenziale)
# - Sicuro (non espone MAC)
# - Best of v1 e v4

# Contro:
# - Relativamente nuovo
# - Timestamp visibile (meno di v1)

# Uso: nuovo standard raccomandato per database

Altre Versioni

# UUIDv3: MD5 hash di namespace + name
# UUIDv5: SHA-1 hash di namespace + name
# Deterministici: stesso input = stesso UUID

const { v5: uuidv5 } = require('uuid');
const MY_NAMESPACE = '1b671a64-40d5-491e-99b0-da01ff1f3341';
const id = uuidv5('example.com', MY_NAMESPACE);
// Sempre lo stesso per 'example.com'

# UUIDv6: Reordered timestamp (draft)
# Come v1 ma con timestamp ordinabile

Generazione UUID

JavaScript/Node.js

// Node.js crypto (UUIDv4)
const { randomUUID } = require('crypto');
const id = randomUUID();  // 'f47ac10b-58cc-4372-a567-0e02b2c3d479'

// Browser crypto
const id = crypto.randomUUID();

// Libreria uuid (tutte le versioni)
const { v1, v4, v5, v7 } = require('uuid');

const id1 = v1();  // Timestamp + MAC
const id4 = v4();  // Random
const id5 = v5('example.com', v5.DNS);  // Deterministico
const id7 = v7();  // Timestamp + random (nuovo)

// Validazione
const { validate, version } = require('uuid');
validate('f47ac10b-58cc-4372-a567-0e02b2c3d479');  // true
version('f47ac10b-58cc-4372-a567-0e02b2c3d479');   // 4

Python

import uuid

# UUIDv4 (random)
id = uuid.uuid4()
print(id)  # 550e8400-e29b-41d4-a716-446655440000
print(str(id))  # Stringa
print(id.hex)   # Senza trattini
print(id.bytes) # 16 byte

# UUIDv1 (timestamp + MAC)
id = uuid.uuid1()

# UUIDv5 (deterministico)
id = uuid.uuid5(uuid.NAMESPACE_DNS, 'example.com')

# Da stringa
id = uuid.UUID('550e8400-e29b-41d4-a716-446655440000')

# UUIDv7 (con libreria)
from uuid6 import uuid7
id = uuid7()

Database

-- PostgreSQL (supporto nativo)
CREATE EXTENSION IF NOT EXISTS "uuid-ossp";

-- UUIDv4
SELECT uuid_generate_v4();
SELECT gen_random_uuid();  -- Built-in (14+)

-- Colonna UUID
CREATE TABLE users (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    email VARCHAR(255)
);

-- MySQL 8.0+
SELECT UUID();  -- v1
SELECT UUID_TO_BIN(UUID());  -- Binary storage (16 byte)

-- Con ordering (v7-like)
SELECT UUID_TO_BIN(UUID(), true);  -- Swap timestamp bytes

UUID vs Alternative

ULID

# ULID: 26 caratteri, ordinabile, Crockford Base32
01ARZ3NDEKTSV4RRFFQ69G5FAV

# Struttura: 10 char timestamp + 16 char random
# Più corto di UUID (26 vs 36)
# Case-insensitive
# Nessun carattere speciale

import { ulid } from 'ulid';
const id = ulid();

# Pro: più compatto, URL-friendly
# Contro: meno diffuso

NanoID

# NanoID: personalizzabile, più corto
import { nanoid } from 'nanoid';

const id = nanoid();     // 21 caratteri
const id = nanoid(10);   // 10 caratteri
// V1StGXR8_Z5jdHi6B-myT

# Alfabeto personalizzabile
import { customAlphabet } from 'nanoid';
const nanoid = customAlphabet('0123456789', 12);

# Pro: molto compatto, personalizzabile
# Contro: non standard, meno entropia

Snowflake ID

# Snowflake: 64-bit, ordinabile, distribuito
# Formato: timestamp | datacenter | worker | sequence

# Pro: dimensione INT (8 byte)
# Contro: richiede coordinazione worker ID

# Usato da: Twitter, Discord, Instagram

Best Practices

Storage

# Database: usa BINARY(16), non VARCHAR(36)
# Risparmio: 20 byte per record

-- PostgreSQL: tipo nativo UUID
id UUID PRIMARY KEY

-- MySQL: BINARY con funzioni
id BINARY(16) PRIMARY KEY,
INDEX idx_id_text ((UUID_TO_BIN(id)))

# Indice: UUIDv7 per inserimenti ordinati
# Evita frammentazione B-tree

URL e API

# URL-safe: nessuna modifica necessaria
/users/550e8400-e29b-41d4-a716-446655440000

# Versione compatta (senza trattini)
/users/550e8400e29b41d4a716446655440000

# Base64 URL-safe (22 caratteri)
/users/VQ6EAOKbQdSnFkRmVUQAAA

Sicurezza

# UUIDv4 è sicuro per:
# - Session token
# - API keys (con prefisso)
# - Password reset links

# NON sicuro:
# - UUIDv1 (espone MAC)
# - UUIDv3/v5 (deterministici)

# Usa crypto-secure RNG
# Node.js crypto.randomUUID() è sicuro
# Non usare Math.random()!

Strumenti Online

Per generare e validare UUID:

• UUID Generator - Genera v4, v7, ULID
• Hash Generator - Per v3/v5
• Base64 Encoder - UUID compatti

Conclusione

Raccomandazioni per UUID:

• Nuovo progetto: UUIDv7 (ordinabile + sicuro)
• Esistente v4: Continua con v4 (no migrazione)
• URL corti: ULID o NanoID
• Database: Storage BINARY(16), non stringa
• Token sicuri: UUIDv4 con crypto RNG

Debugging UUID

# Decodifica versione e variante
function parseUUID(uuid) {
  const version = parseInt(uuid.charAt(14), 16);
  const variant = parseInt(uuid.charAt(19), 16);
  return { version, variant };
}

# Valida formato UUID
const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-7][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;

Per altri strumenti utili, esplora i nostri tool online gratuiti. Per la specifica completa, consulta RFC 4122.