Gerador GUID
Gerar GUIDs (Identificadores Únicos Globais) em vários formatos
Experimentar a Ferramenta
Introdução
O Gerador GUID cria Identificadores Únicos Globais (GUIDs) em vários formatos. GUIDs são identificadores únicos de 128 bits que são estatisticamente garantidos para serem únicos no espaço e no tempo. São comumente usados no desenvolvimento de software para identificar recursos, registros de banco de dados e sistemas distribuídos.
Como Usar
- Selecione o formato GUID (padrão, maiúsculas, sem hífens, etc.)
- Digite o número de GUIDs a gerar
- Clique em "Gerar" para criar GUIDs
- Veja os GUIDs gerados na área de saída
- Copie GUIDs individuais ou todos de uma vez
Casos de Uso
- Gerar identificadores únicos para registros de banco de dados
- Criar GUIDs para componentes de sistemas distribuídos
- Gerar IDs únicos para endpoints de API
- Criar identificadores para rastrear recursos
Dicas
- GUIDs são valores de 128 bits representados como 32 caracteres hexadecimais
- Formato padrão: 8-4-4-4-12 caracteres separados por hífens
- GUIDs não diferenciam maiúsculas/minúsculas mas frequentemente são exibidos em maiúsculas
- Cada GUID é virtualmente garantido para ser único
- Use GUIDs quando precisar de identificadores globalmente únicos
O que é Gerador GUID?
Um GUID (Globally Unique Identifier, identificador globalmente único) é o nome dado pela Microsoft ao UUID (Universally Unique Identifier, identificador universalmente único), um identificador de 128 bits representado como 36 caracteres: 32 dígitos hexadecimais mais 4 hifens, como `{550e8400-e29b-41d4-a716-446655440000}`. As chaves são uma convenção da Microsoft; UUIDs padrão as omitem. A RFC 4122 define cinco versões de UUID: v1 (carimbo de data/hora + endereço MAC, vazamento de privacidade), v3 (hash MD5 de namespace + nome, determinístico), v4 (122 bits aleatórios de um PRNG criptográfico, o padrão para `crypto.randomUUID()` e a maioria das APIs), v5 (hash SHA-1, determinístico) e v7 (carimbo de data/hora em milissegundos de 48 bits + aleatório, ordenável - mais recente). GUIDs são usados em chaves de registro do Windows, identificadores de componentes COM (CLSID/IID), `System.Guid` do .NET, `UNIQUEIDENTIFIER` do SQL Server e qualquer sistema que precise de IDs globalmente únicos sem coordenação central. O espaço teórico de colisão é 2^128 (aproximadamente 3.4 × 10^38), tornando duplicatas acidentais astronomicamente improváveis quando geradas a partir de um RNG criptográfico.
Casos de uso comuns
Chaves primárias no .NET e SQL Server
O ecossistema da Microsoft usa GUIDs extensivamente: `System.Guid` no .NET, `UNIQUEIDENTIFIER` no SQL Server. Armazenados como 16 bytes binários, eles permitem a geração distribuída de IDs entre microsserviços sem coordenação. O método `Guid.NewGuid()` do .NET produz v4 por padrão. A função `NEWID()` do SQL Server também retorna v4, enquanto `NEWSEQUENTIALID()` produz GUIDs sequenciais do tipo v1 que reduzem a fragmentação de índice em chaves primárias clusterizadas - uma otimização crítica para tabelas com alta escrita.
Identificadores de registro do Windows e COM
O Windows usa GUIDs (chamados CLSID para classes, IID para interfaces) para identificar componentes COM, extensões de shell e chaves de registro. O famoso `{00000000-0000-0000-0000-000000000000}` é o GUID NULL; `{00000000-0000-0000-C000-000000000046}` é IUnknown. Ferramentas como `regedit` e `oleview` exibem esses GUIDs, e os desenvolvedores geram novos com `uuidgen` (Visual Studio) ou `guidgen` (PowerShell `New-Guid`). As chaves são convencionais em caminhos de registro: `HKCR\CLSID\{...}`.
Geração distribuída de IDs multiplataforma
Sistemas distribuídos modernos (Kafka, Cassandra, sistemas event-sourced) precisam de IDs globalmente únicos entre nós sem um alocador central. O GUID v4 funciona, mas causa fragmentação de índice em bancos de dados porque valores aleatórios espalham inserções entre páginas B-tree. O GUID v7 (RFC 9562, 2024) resolve isso embutindo um carimbo de data/hora em milissegundos de 48 bits, tornando novos GUIDs ordenáveis e amigáveis a acréscimos. Muitos sistemas agora usam v7 como padrão para novos bancos de dados.
Exemplos de código
Gerando GUIDs em diferentes formatos
O mesmo GUID de 128 bits pode ser renderizado em muitos formatos: padrão com hifens, com chaves (convenção de registro/COM da Microsoft), em maiúsculas (padrão do SQL Server) ou em formato compacto de 32 caracteres (sem hifens, usado em URLs e armazenamento curto). O `Guid.ToString()` do .NET aceita especificadores de formato: "B" para chaves, "N" para sem hifens, "P" para parênteses. O `NEWSEQUENTIALID()` do SQL Server produz GUIDs que incrementam dentro de uma máquina, reduzindo divisões de página em índices clusterizados - uma otimização essencial para tabelas com alta escrita.
// JavaScript / TypeScript - browser & Node 18+
const guid = crypto.randomUUID();
// "550e8400-e29b-41d4-a716-446655440000" (no braces)
// Add braces (Microsoft registry convention)
const withBraces = `{${guid}}`;
// "{550e8400-e29b-41d4-a716-446655440000}"
// Uppercase (SQL Server UNIQUEIDENTIFIER style)
const upper = guid.toUpperCase();
// "550E8400-E29B-41D4-A716-446655440000"
// Hyphen-stripped (compact 32-char form)
const compact = guid.replace(/-/g, '');
// "550e8400e29b41d4a716446655440000"
// C# / .NET
Guid g = Guid.NewGuid(); // v4
string s = g.ToString(); // "550e8400-e29b-41d4-..."
string b = g.ToString("B"); // "{550e8400-e29b-41d4-...}"
string n = g.ToString("N"); // "550e8400e29b41d4..." (no hyphens)
string p = g.ToString("P"); // "(550e8400-e29b-41d4-...)"
// PowerShell
$guid = [guid]::NewGuid() # v4
$guid.ToString("B") # "{550e8400-e29b-...}"
# Or use the cmdlet
$guid = New-Guid
// SQL Server
-- SELECT NEWID() -- random v4
-- SELECT NEWSEQUENTIALID() -- sequential (less fragmentation)Validação e análise de GUIDs
A expressão regular de validação impõe a estrutura da RFC 4122: grupos hexadecimais 8-4-4-4-12, com o dígito de versão (primeiro caractere do 4º grupo) restrito a 1-8 e o dígito de variante (primeiro caractere do 5º grupo) restrito a 8, 9, a ou b. Isso captura GUIDs malformados como `00000000-0000-0XXX-0XXX-000000000000` mesmo quando correspondem ao padrão de caracteres. A função `guidInfo` extrai a versão (1-8) e a variante (RFC 4122, NCS, Microsoft, Reserved) de um GUID válido.
// RFC 4122 validation regex (case-insensitive)
const guidRegex = /^{?[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}}?$/i;
function isValidGuid(str) {
return guidRegex.test(str);
}
console.log(isValidGuid('550e8400-e29b-41d4-a716-446655440000')); // true
console.log(isValidGuid('{550e8400-e29b-41d4-a716-446655440000}')); // true (braces)
console.log(isValidGuid('550E8400-E29B-41D4-A716-446655440000')); // true (upper)
console.log(isValidGuid('not-a-guid')); // false
console.log(isValidGuid('550e8400-e29b-01d4-a716-446655440000')); // false (v0)
console.log(isValidGuid('550e8400-e29b-41d4-c716-446655440000')); // false (variant)
// Extract version and variant
function guidInfo(str) {
const clean = str.replace(/[{}-]/g, '').toLowerCase();
const version = parseInt(clean[12], 16);
const variantChar = parseInt(clean[16], 16);
const variant = variantChar >= 8 && variantChar <= 0xb ? 'RFC 4122' :
variantChar === 0 ? 'NCS' :
variantChar >= 0xc && variantChar <= 0xf ? 'Microsoft' :
'Reserved';
return { version, variant };
}Melhores práticas
- ✓Use GUID v4 (`crypto.randomUUID()` ou `Guid.NewGuid()`) por padrão - é a variante mais segura e amplamente suportada para IDs aleatórios.
- ✓Para chaves primárias de bancos de dados com alta escrita, prefira GUID v7 (RFC 9562) ou `NEWSEQUENTIALID()` do SQL Server para evitar a fragmentação de páginas B-tree.
- ✓Armazene GUIDs como binários de 16 bytes (PostgreSQL uuid, SQL Server UNIQUEIDENTIFIER) em vez de CHAR(36) - 2,25x menor e mais rápido de indexar.
- ✓No .NET, use `Guid.ToString("B")` para caminhos de registro/COM (chaves), `ToString("D")` para exibição padrão, `ToString("N")` para armazenamento compacto.
- ✓Sempre valide GUIDs com um regex que verifica os dígitos de versão e variante, não apenas o padrão de caracteres - GUIDs malformados causam bugs silenciosos.
Erros comuns a evitar
- ✗Gerar GUIDs com `Math.random()` em vez de `crypto.getRandomValues` - RNGs não criptográficos causam colisões em grande escala.
- ✗Usar GUID v1 em sistemas voltados para o cliente - o endereço MAC incorporado vaza o fornecedor e o identificador da placa de rede do servidor.
- ✗Armazenar GUIDs como VARCHAR(36) no SQL Server em vez de UNIQUEIDENTIFIER - desperdiça 2,25x de espaço e é mais lento para buscas de índice.
- ✗Truncar GUIDs para "economizar espaço" (pegando os primeiros 8 caracteres) - destrói a resistência a colisões, duplicatas prováveis em milhares de linhas.
- ✗Misturar formatos de GUID (com chaves vs sem chaves) na mesma coluna de banco de dados - causa falhas de comparação de strings e bugs de join.
Pesquisas relacionadas
Ferramentas Recomendadas
Gerador de UUID
Gerar UUID v1 e v4
Em DestaqueGerador de Endereço MAC
Gerar endereços MAC aleatórios
Gerador Htpasswd
Gerar entradas htpasswd para autenticação Apache
Gerador de Hash Bcrypt
Gerar hashes de senha Bcrypt com rodadas de sal personalizáveis
Gerador de Hash Scrypt
Gerar hashes de senha Scrypt com parâmetros personalizáveis
Gerador de Hash de Senha MySQL
Gerar hashes de senha MySQL usando vários algoritmos de hash