🔧

Gerador GUID

Gerar GUIDs (Identificadores Únicos Globais) em vários formatos

guiduuidgeneratoridentifier

Experimentar a Ferramenta

Be the first to rate

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

  1. Selecione o formato GUID (padrão, maiúsculas, sem hífens, etc.)
  2. Digite o número de GUIDs a gerar
  3. Clique em "Gerar" para criar GUIDs
  4. Veja os GUIDs gerados na área de saída
  5. 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

gerador de guid com chavesdiferença guid vs uuidc# guid tostring especificadores de formatosql server newid vs newsequentialidcrypto randomuuid javascriptguid v7 rfc 9562 ordenávelvalidação regex guid rfc 4122cmdlet powershell new-guid