Gerador de UUID

O que é UUID?

UUID (Identificador Universalmente Único) é um identificador de 128 bits usado em sistemas de computador para identificar informações de forma única. O UUID é padronizado de acordo com a RFC 4122 e, devido à sua enorme entropia, garante uma probabilidade praticamente nula de colisão – o que significa que dois UUIDs gerados independentemente serão quase certamente únicos.

O UUID possui um formato padrão: xxxxxxxx-xxxx-Mxxx-Nxxx-xxxxxxxxxxxx, onde cada x é um dígito hexadecimal (0-9, a-f), M indica a versão do UUID e N indica a variante.

Versões de UUID

UUID v1 (Carimbo de Data/Hora + Endereço MAC)

O UUID v1 é baseado no carimbo de data/hora atual (timestamp) e um valor aleatório (no navegador, em vez do endereço MAC). Ele usa intervalos de 100 nanosegundos a partir de 15 de outubro de 1582 (calendário Gregoriano).

Uso:

• Situações em que você precisa de ordenação cronológica de UUIDs
• Depuração e registro (o UUID contém informações sobre o tempo de criação)
• Sistemas distribuídos com sincronização de tempo

Exemplo: 6ba7b810-9dad-11d1-80b4-00c04fd430c8

Vantagens:

• UUIDs podem ser ordenados cronologicamente pelo tempo de criação
• Útil para auditoria e depuração
• Contém informações de carimbo de data/hora

Desvantagens:

• Potencial risco de segurança – contém carimbo de data/hora
• No navegador, não contém o endereço MAC real (substituído por um valor aleatório)
• Má localidade de DB (o carimbo de data/hora está nos bits de ordem baixa)

UUID v3 (Hash MD5)

O UUID v3 é gerado usando o hash MD5 de um UUID de namespace e um nome. Determinístico – o mesmo namespace + nome sempre criará o mesmo UUID.

Uso:

• Conversão de URLs, nomes DNS ou outros identificadores para UUIDs
• Situações em que você precisa de UUIDs reproduzíveis
• Mapeamento entre diferentes sistemas de identificação

Exemplo: a3bb189e-8bf9-3888-9912-ace4e6543002

Vantagens:

• Determinístico (mesma entrada = mesma saída)
• Ideal para converter identificadores conhecidos
• Nenhuma colisão para diferentes entradas

Desvantagens:

• MD5 é um algoritmo obsoleto (prefira v5)
• Requer namespace e nome
• Não é possível recuperar a entrada original

UUID v4 (Aleatório) - RECOMENDADO

A versão mais usada de UUID. O UUID v4 é gerado puramente aleatoriamente usando um gerador de números aleatórios criptograficamente seguro (crypto.getRandomValues()).

Uso:

• Chaves primárias de banco de dados
• Identificadores de sessão (IDs de sessão)
• Nomes de arquivo únicos
• Tokens de API
• Propósitos gerais onde você precisa de IDs garantidamente únicos

Exemplo: f47ac10b-58cc-4372-a567-0e02b2c3d479

Vantagens:

• Entropia e segurança máximas
• Nenhuma dependência de tempo ou parâmetros do sistema
• Implementação mais simples

Probabilidade de colisão: Ao gerar 1 bilhão de UUIDs por segundo por 100 anos, a chance de colisão é de aproximadamente 0,00000006%.

UUID v5 (Hash SHA-1)

O UUID v5 é o mesmo que o v3, mas usa SHA-1 em vez de MD5. Uma alternativa mais moderna e segura ao v3.

Uso:

• O mesmo que o v3, mas com melhor segurança
• Preferível ao v3 para novos projetos
• Geração de UUIDs a partir de URLs, nomes DNS, OID, X.500 DN

Exemplo: 886313e1-3b8a-5372-9b90-0c9aee199e5d

Vantagens:

• Determinístico
• SHA-1 é mais robusto que MD5
• Adequado para mapeamento entre sistemas

Desvantagens:

• SHA-1 também é considerado obsoleto (mas ainda mais seguro que MD5)
• Requer namespace e nome

UUID v6 (Carimbo de Data/Hora Ordenado)

O UUID v6 é uma versão aprimorada do v1 com bits de tempo rearranjados para melhor indexação em DB. Projetado para resolver problemas de localidade em bancos de dados.

Uso:

• Chaves primárias de banco de dados com ordenação por tempo
• Sistemas que exigem ordenação cronológica e desempenho de DB
• Alternativa mais moderna ao v1

Exemplo: 1ec9414c-232a-6b00-b3c8-9e6bdeced846

Vantagens:

• Melhor localidade de DB do que v1 (carimbo de data/hora em bits de ordem alta)
• Ordenação cronológica
• Compatível com o padrão UUID

Desvantagens:

• Menos usado que v1/v4
• Ainda contém informações de tempo (risco de segurança)

UUID v7 (Carimbo de Data/Hora Unix)

O UUID v7 usa o carimbo de data/hora Unix (milissegundos desde 1970) + bits aleatórios. A versão mais recente de UUID com a melhor localidade de DB.

Uso:

• Chaves primárias de banco de dados modernas
• Sistemas que exigem desempenho + ordenação por tempo
• Substituição para v1/v6 em novos projetos

Exemplo: 017f22e2-79b0-7cc3-98c4-dc0c0c07398f

Vantagens:

• Melhor localidade de DB de todas as versões
• O carimbo de data/hora Unix é padrão
• Combina as vantagens de aleatoriedade e ordenação por tempo

Desvantagens:

• Especificação relativamente nova (RFC 4122bis)
• Menos suportado em sistemas legados

Qual versão de UUID usar?

Guia de decisão

Precisa de segurança e aleatoriedade máximas? → Use UUID v4 (a escolha mais comum)

Precisa de ordenação por tempo e desempenho de DB? → Use UUID v7 (moderno) ou UUID v6 (padrão)

Precisa de UUIDs reproduzíveis a partir de identificadores existentes? → Use UUID v5 (SHA-1) ou UUID v3 (MD5, legado)

Precisa de carimbo de data/hora e trilha de auditoria? → Use UUID v1 (legado, pior desempenho de DB)

Bancos de dados

Para novos projetos: UUID v7 ou v4

• v7 é ideal para ordenação por tempo + desempenho
• v4 para aleatoriedade máxima sem informações de tempo

Para sistemas legados: UUID v1 ou v6

• v6 tem melhor localidade de DB que v1
• v1 é amplamente suportado

Vantagens do UUID como chave primária:

• Unicidade global – Você pode conectar dados de diferentes bancos de dados sem conflito
• Segurança – Ao contrário dos IDs sequenciais (1, 2, 3…), não é possível adivinhar os próximos valores
• Sistemas distribuídos – UUIDs podem ser gerados independentemente em vários servidores sem coordenação
• Fusão de bancos de dados – Nenhuma colisão ocorre ao mesclar dois bancos de dados

Desvantagens:

• Tamanho maior (16 bytes vs 4-8 bytes para inteiro)
• Indexação mais lenta em alguns bancos de dados (use v6/v7 para melhor desempenho)
• Menos legível para humanos

API e serviços web

• REST API – Identificadores únicos para recursos
• GraphQL – Identificadores globais para nós
• Webhooks – Rastreamento de solicitações e respostas
• Tokens – IDs de sessão, tokens de atualização

Arquivos e armazenamento

• Nomes de arquivo – Prevenção de colisões no upload
• S3/Cloud Storage – Caminhos de objeto únicos
• Chaves de cache – Identificadores em sistemas de cache

Aplicações Frontend

• Componentes React/Vue – Chaves únicas para listas
• IDs Temporários – IDs antes de salvar no banco de dados
• Armazenamento local – Chaves para dados armazenados
• Aplicações offline-first – Geração de IDs sem conexão com o servidor

Funções avançadas do gerador

Geração de UUID com tempo personalizado

Para versões baseadas em tempo (v1, v6, v7), você pode selecionar qualquer carimbo de data/hora usando um seletor de data e hora. Isso é útil para:

Testes:

• Simulação de UUIDs criados no passado
• Teste de ordenação por tempo em bancos de dados
• Reprodução de UUIDs para depuração

Migração de dados:

• Geração de UUIDs com carimbos de data/hora históricos
• Preenchimento de dados com valores de carimbo de data/hora corretos
• Importação de dados de diferentes períodos de tempo

Auditoria e conformidade:

• Reconstrução de UUIDs de acordo com o tempo de criação do registro
• Geração retroativa de identificadores

Exemplo de uso:

1. Selecione a versão v1, v6 ou v7
2. Defina a data e hora usando o seletor de data e hora
3. Gere UUIDs com seu carimbo de data/hora personalizado

UUIDs baseados em Hash (v3, v5)

Para UUIDs determinísticos, você pode usar as versões v3 (MD5) ou v5 (SHA-1):

Como usar:

1. Selecione o namespace de acordo com o tipo do seu identificador
2. Insira o nome/valor
3. Gere o UUID

Exemplos:

Propriedades importantes:

• ✅ Determinístico: Mesma entrada = sempre o mesmo UUID
• ✅ Reproduzível: Você pode recriar o UUID a qualquer momento
• ✅ Consistente: O mesmo UUID em diferentes sistemas
• ❌ Não decodificável: Não é possível obter o nome original a partir do UUID
• ℹ️ Um UUID: Para v3/v5, apenas um UUID é sempre gerado (mesma entrada = mesma saída)

Uso prático:

// Exemplo: Conversão de URL para UUID v5
Namespace: URL
Nome: https://example.com/api/users/123
Resultado: 886313e1-3b8a-5372-9b90-0c9aee199e5d

// Mesma entrada = sempre o mesmo UUID
Namespace: DNS
Nome: google.com
Resultado: sempre o mesmo UUID para google.com

Como usar UUIDs com segurança?

Segurança criptográfica

Nosso gerador usa crypto.getRandomValues(), que é um gerador de números aleatórios criptograficamente seguro. Ao contrário de Math.random(), que é previsível e inadequado para fins de segurança, crypto.getRandomValues() fornece entropia real adequada para:

• Geração de tokens de segurança
• IDs de sessão
• Chaves de API
• Aplicações criptográficas

Comparação de versões de UUID

UUID vs outros identificadores

Implementação em diferentes linguagens

JavaScript/TypeScript

// UUID v4 - A maneira mais simples (navegadores modernos)
const uuid = crypto.randomUUID();

// UUID v4 - Implementação manual
function generateUUIDv4() {
  return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
    const r = (crypto.getRandomValues(new Uint8Array(1))[0] & 0x0f) >> (c === 'x' ? 0 : 2);
    const v = c === 'x' ? r : (r & 0x3) | 0x8;
    return v.toString(16);
  });
}

// UUID v7 - Recomendado para bancos de dados
function generateUUIDv7() {
  const timestamp = Date.now();
  const timeHi = (timestamp >> 16).toString(16).padStart(8, '0');
  const timeLow = (timestamp & 0xFFFF).toString(16).padStart(4, '0');

  const randomBytes = crypto.getRandomValues(new Uint8Array(10));
  const randomHex = Array.from(randomBytes)
    .map(b => b.toString(16).padStart(2, '0'))
    .join('');

  return `${timeHi}-${timeLow}-7${randomHex.substr(0, 3)}-${randomHex.substr(3, 4)}-${randomHex.substr(7)}`;
}

Python

import uuid

# UUID v4
uuid_v4 = str(uuid.uuid4())
# Output: '6ba7b810-9dad-11d1-80b4-00c04fd430c8'

# UUID v1
uuid_v1 = str(uuid.uuid1())

Java

import java.util.UUID;

// UUID v4
String uuidV4 = UUID.randomUUID().toString();

PHP

// UUID v4 (PHP 7+)
function generateUUID() {
    return sprintf('%04x%04x-%04x-%04x-%04x-%04x%04x%04x',
        mt_rand(0, 0xffff), mt_rand(0, 0xffff),
        mt_rand(0, 0xffff),
        mt_rand(0, 0x0fff) | 0x4000,
        mt_rand(0, 0x3fff) | 0x8000,
        mt_rand(0, 0xffff), mt_rand(0, 0xffff), mt_rand(0, 0xffff)
    );
}

C#

using System;

// UUID v4
Guid uuid = Guid.NewGuid();
string uuidString = uuid.ToString();

Melhores Práticas

Armazenamento de UUID em banco de dados

PostgreSQL:

CREATE TABLE users (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    email VARCHAR(255) NOT NULL,
    created_at TIMESTAMP DEFAULT NOW()
);

MySQL 8.0+:

CREATE TABLE users (
    id BINARY(16) PRIMARY KEY DEFAULT (UUID_TO_BIN(UUID())),
    email VARCHAR(255) NOT NULL,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

Dica: No MySQL, armazene UUIDs como BINARY(16) em vez de CHAR(36) para economizar espaço e indexação mais rápida.

Validação de UUID

function isValidUUID(uuid) {
  const regex = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
  return regex.test(uuid);
}

Conversão de UUID

// Remoção de hífens
const compact = uuid.replace(/-/g, '');

// Adição de hífens de volta
function formatUUID(compactUuid) {
  return [
    compactUuid.substring(0, 8),
    compactUuid.substring(8, 12),
    compactUuid.substring(12, 16),
    compactUuid.substring(16, 20),
    compactUuid.substring(20, 32)
  ].join('-');
}

Resolução de problemas (Troubleshooting)

UUID v3/v5 não funciona

Problema: Nada é gerado após selecionar v3 ou v5

Solução:

1. ✅ Verifique se você preencheu o campo “Nome” - é obrigatório!
2. ✅ Selecione o namespace correto de acordo com o tipo da sua entrada
3. ✅ Exemplos de entradas válidas:
   • DNS: example.com, google.com
   • URL: https://example.com/page
   • Qualquer texto: minha-aplicacao-v1

Dica: Tente primeiro um valor simples como teste e o namespace DNS.

UUIDs baseados em tempo (v1, v6, v7) têm um tempo estranho

Problema: O UUID gerado tem um carimbo de data/hora inesperado

Solução:

1. ✅ Verifique o seletor de data e hora - o tempo está configurado corretamente?
2. ✅ O seletor de data e hora usa seu fuso horário local
3. ✅ Deixe o seletor de data e hora vazio para o tempo atual

O UUID não pode ser copiado

Problema: O botão “Copiar tudo” não funciona

Solução:

1. ✅ Verifique se você gerou UUIDs (não estão vazios)
2. ✅ Alguns navegadores exigem HTTPS para a API da área de transferência
3. ✅ Alternativamente, selecione o texto na caixa de texto e copie manualmente (Ctrl+C)

Perguntas Frequentes (FAQ)

Alternativas ao UUID

ULID (Identificador Universalmente Único Classificável Lexicograficamente)

• ID de 128 bits (o mesmo que UUID)
• Classificável lexicograficamente pelo tempo de criação
• Representação mais compacta (26 caracteres em vez de 36)
• Codificação base32 sem distinção entre maiúsculas e minúsculas

Exemplo: 01ARZ3NDEKTSV4RRFFQ69G5FAV

NanoID

• Tamanho menor que UUID (21 caracteres por padrão)
• Amigável para URL (sem caracteres especiais)
• Geração mais rápida
• Comprimento e alfabeto configuráveis

Exemplo: V1StGXR8_Z5jdHi6B-myT

Snowflake ID (Twitter)

• ID de 64 bits (menor que UUID)
• Classificável por tempo
• Contém ID de worker e número de sequência
• Requer configuração centralizada

Exemplo: 1234567890123456789

Desempenho e otimização

Velocidade de geração

Nosso gerador pode gerar:

• 1 UUID: < 1 ms
• 100 UUIDs: ~10-20 ms
• 1000 UUIDs: ~100-200 ms

Dicas de desempenho

1. Geração em lote – Se precisar de muitos UUIDs, gere-os de uma vez em vez de um por um
2. Armazenamento em DB – Indexe as colunas UUID para buscas rápidas
3. Compressão – Armazene UUIDs em formato binário (16 bytes) em vez de string (36 bytes)
4. Cache – Em alguns casos, você pode pré-gerar e armazenar UUIDs em cache

Para desenvolvedores

Estrutura do UUID v4

xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx
|        |    |    |    |
|        |    |    |    └─ 48 bits de dados aleatórios (node)
|        |    |    └────── 16 bits de dados aleatórios com variante (clock_seq)
|        |    └─────────── 12 bits de dados aleatórios + 4 bits de versão (time_hi_and_version)
|        └──────────────── 16 bits de dados aleatórios (time_mid)
└───────────────────────── 32 bits de dados aleatórios (time_low)

• Versão (4 bits): sempre 0100 (binário) = 4 (hex)
• Variante (2-3 bits): sempre 10 (binário) para RFC 4122

Teste de UUID

// Teste Jest
describe('Gerador de UUID', () => {
  test('gera UUID v4 válido', () => {
    const uuid = generateUUIDv4();
    const regex = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
    expect(regex.test(uuid)).toBe(true);
  });

  test('gera UUIDs únicos', () => {
    const uuid1 = generateUUIDv4();
    const uuid2 = generateUUIDv4();
    expect(uuid1).not.toBe(uuid2);
  });
});

Aspectos de segurança

O que não fazer com UUIDs

❌ Não use UUID v1 para aplicações sensíveis – Contém carimbo de data/hora, o que pode ser um risco de segurança

❌ Não use Math.random() para gerar UUIDs – Não é criptograficamente seguro

❌ Não dependa de UUIDs para autorização – UUIDs podem ser adivinhados (embora com probabilidade extremamente baixa)

❌ Não armazene UUIDs em cookies sem criptografia – Use cookies assinados ou JWT

O que fazer

✅ Use UUID v4 para a maioria dos casos – Maior entropia e segurança

✅ Combine UUIDs com outras medidas de segurança – Para gerenciamento de sessão, use HTTPS, cookies HttpOnly e expiração curta

✅ Valide UUIDs no servidor – Sempre verifique o formato e a versão do UUID

✅ Use fontes de aleatoriedade criptograficamente seguras – crypto.getRandomValues() no navegador, /dev/urandom no Linux

Curiosidades

• Número de UUIDs v4 possíveis: 2^122 ≈ 5.3 × 10^36 (340 undecilhões)
• Colisão necessária: Para uma chance de 50% de colisão, você deve gerar 2.71 × 10^18 UUIDs (2.71 quintilhões)
• Tamanho de todos os UUIDs possíveis: Se cada UUID fosse armazenado como 16 bytes, todo o espaço ocuparia 85 zettabytes (85 bilhões de terabytes)
• Origem: O UUID foi padronizado como parte do DCE (Distributed Computing Environment) em 1990