Precisa de um identificador que não colidirá com outro criado por outra pessoa, numa máquina da qual nunca ouviu falar, sem pedir autorização a ninguém? Esse é o trabalho de um UUID. É um número de 128 bits, escrito como 36 carateres no padrão familiar de 8-4-4-4-12, e todo o seu design serve para que não haja dois iguais, mesmo que nada coordene quem recebe o quê. Este gerador gratuito cria-os no navegador: escolha uma versão em «Versão», indique quantos precisa em «Quantidade» e prima «Gerar». A página abre com um único v4, a versão que a maioria dos projetos quer, por isso o primeiro identificador está à distância de um clique.
Cada identificador é construído pelo navegador através da Web Crypto API. A versão 4 utiliza crypto.randomUUID() caso o navegador a forneça e crypto.getRandomValues() nos restantes casos — uma fonte criptograficamente forte de aleatoriedade, em vez de uma função pseudoaleatória do JavaScript como Math.random(). A versão 7 coloca um carimbo de data/hora de 48 bits em milissegundos na frente, seguido de um contador de 12 bits que aumenta dentro do mesmo milissegundo, e depois 62 bits aleatórios, que é o método de ordenação descrito na RFC 9562; esse contador é a razão pela qual um lote de mil sai por ordem em vez de baralhado. A versão 1 combina um carimbo de data/hora com um identificador de nó aleatório que tem o bit multicast ativado, pelo que nunca carrega o endereço da placa de rede à maneira das implementações originais da década de 1990. As versões 3 e 5 não são nada aleatórias: fazem o hash de um namespace juntamente com um nome, utilizando MD5 e SHA-1 respetivamente, e esse hash também acontece no dispositivo. Nada é enviado para um servidor, nada é registado, e depois de a página carregar continuará a funcionar com a ligação desligada.
«Versão» é o campo que decide tudo o resto. A versão 4 possui 122 bits aleatórios e nenhuma estrutura — a predefinição, e a resposta certa quando um identificador só precisa de ser único. A versão 7 mantém 62 bits aleatórios, mas começa com o momento em que foi criada, de modo que um conjunto deles é ordenado pela ordem em que foram feitos; é isto que faz dela a versão a escolher quando o identificador se vai tornar uma chave de base de dados. A versão 1 é o esquema original baseado no tempo, mantido aqui para os sistemas que ainda a pedem. As versões 3 e 5 são o par diferente: são determinísticas, o que significa que as mesmas entradas produzem sempre o mesmo identificador, e levam dois campos extra — «Namespace», que é um dos espaços padrão DNS, URL, OID e X.500 ou um espaço «Personalizado» próprio, e «Nome», a string a ser identificada. Alimentando a v5 com o namespace URL e https://example.com/a obterá o mesmo UUID hoje, amanhã e na máquina de outra pessoa. Por causa disto, «Quantidade» desaparece quando a v3 ou a v5 é selecionada: mil cópias de um valor determinístico seriam apenas mil cópias de um valor determinístico. Para todas as outras versões, «Quantidade» vai de 1 a 1000.
Quatro interruptores alteram o formato da saída sem alterar os 128 bits subjacentes. «Maiúsculas» imprime os dígitos hexadecimais em caixa alta, «Sem hífenes» fornece a forma compacta de 32 carateres que algumas colunas e nomes de ficheiros preferem, e «Chavetas» envolve o valor em { } — a forma que o Windows e o mundo .NET chamam GUID. Em «Opções avançadas», urn:uuid: adiciona o prefixo que o torna num URN formal; este desliga «Chavetas» e «Sem hífenes» enquanto está ativado, porque a norma permite exatamente uma forma URN e é a forma canónica com hífenes. «Formato de cópia» decide como um lote é juntado quando o recolhe: um por linha, separados por vírgulas, ou cada valor entre aspas com uma vírgula no final, que cola diretamente num array em código. Sob o resultado fica uma linha que relata a aleatoriedade em bits — 122 para a v4, 62 para a v7 — e, no caso da v7, o carimbo de data/hora codificado no primeiro identificador do lote, para que o tempo dentro do valor fique visível em vez de implícito. «Copiar tudo» e «Guardar em ficheiro» respeitam o «Formato de cópia». «Histórico» guarda os últimos 10 lotes no próprio navegador: clique num para o trazer de volta, copie ou elimine uma única entrada, ou limpe tudo. «Limpar» esvazia o resultado e deixa as definições como estão, e, após 50 identificadores, a lista torna-se um único bloco rolável em vez de cinquenta linhas.
A coisa mais consequente nesta página é a diferença entre a v4 e a v7 como chave primária, e não é uma questão de gosto. Os índices de bases de dados são árvores B mantidas por ordem de ordenação, e o local onde uma nova chave calha nessa ordem decide quanto trabalho o insert custa. Uma chave v4 é aleatória, pelo que os inserts consecutivos caem em cantos não relacionados do índice: páginas que estavam cheias são divididas, as partes da árvore que a base de dados mantém em memória raramente são as partes de que o próximo insert precisa, e o índice acaba maior e mais fragmentado do que as linhas para as quais aponta justificam. Uma chave v7 começa com o milissegundo atual, pelo que inserts consecutivos calham uns ao lado dos outros na margem direita da árvore, que é o padrão que um número inteiro de incremento automático produz e o padrão em torno do qual as estruturas de índice foram criadas. Esta é toda a contrapartida: a v7 dá o comportamento de insert de uma chave sequencial, ao mesmo tempo que mantém a propriedade que o fez escolher UUIDs em primeiro lugar, que é o facto de que qualquer um pode cunhar um sem perguntar a um servidor. O que isso custa é que o tempo de criação agora pode ser lido dentro do identificador, e se isso importa é uma questão sobre os dados, não sobre o formato.
Nada nunca verifica a unicidade de um UUID; o seu tamanho é a garantia. Não há nenhum registo, nenhuma viagem de ida e volta a um servidor, nenhuma pesquisa — um gerador produz um número e entrega-o, e a razão pela qual dois deles não colidem é simplesmente porque há 2^122 valores possíveis de v4, cerca de 5,3 sextiliões. O problema do aniversário é a maneira honesta de dimensionar isto: precisaria de cerca de 2,7 triliões de identificadores antes de haver uma probabilidade de 50% de dois deles coincidirem, o que equivale a mil milhões de novos UUIDs por segundo durante 86 anos. Vale a pena ser preciso sobre o que isto promete ou não. É uma garantia estatística, não aritmética, e só é válida enquanto a aleatoriedade subjacente for real — um gerador mal semeado, ou uma máquina virtual clonada juntamente com a sua pool de entropia, quebra-a de uma forma que o formato não consegue detetar. A versão 7 restringe a questão ainda mais: dentro de um único milissegundo, um gerador não consegue repetir-se de forma alguma, porque o contador incrementa em vez de atirar dados, e em geradores independentes os 62 bits aleatórios fazem o trabalho.
Um UUID é um identificador, não uma palavra-passe. A versão 4 é imprevisível, e isso tenta as pessoas a tratá-la como um segredo — uma ligação de reposição de palavra-passe, um URL impossível de adivinhar, um token de sessão, uma chave de API. A imprevisibilidade é real, mas o sigilo é uma propriedade de como um valor é manuseado, e os identificadores são manuseados sem cuidado por conceção. Ao abrigo de regimes de proteção de dados como o RGPD, os identificadores são apenas dados de contexto e acabam em URLs, no histórico do navegador, em registos do servidor, em cabeçalhos de referrer e analytics, e são colados em mensagens de chat. As outras versões são candidatos ainda piores. Tanto a versão 1 como a versão 7 codificam o momento da criação, pelo que qualquer pessoa que tenha uma delas sabe aproximadamente quando foi feita e pode restringir a vizinhança de tudo o que foi criado ao mesmo tempo. As versões 3 e 5 são determinísticas de propósito: um UUID v5 de um endereço de e-mail não é um segredo com hash, é um valor que qualquer um com o mesmo endereço pode calcular num segundo. Utilize um UUID para nomear uma coisa. Utilize um gerador de palavras-passe, ou um token de uma biblioteca feita para segredos, quando o valor tiver de permanecer desconhecido.
Por que escolher este gerador de UUIDs?
- Geração apenas no navegador: os identificadores são feitos no dispositivo e nunca são enviados para lado nenhum
- Aleatoriedade da Web Crypto API: criptograficamente segura, não é Math.random()
- Cinco versões num só lugar: v1, v3, v4, v5 e v7, sem mudar de ferramenta
- v7 genuinamente ordenada: um contador dentro do milissegundo, como a RFC 9562 descreve
- v3 e v5 determinísticas com os quatro namespaces padrão ou o seu próprio
- Até 1000 de cada vez, com uma lista rolável compacta a partir dos cinquenta
- Todas as formas comuns: com hífenes, formato simples, maiúsculas, com chavetas ou um URN urn:uuid:
- Cópia em linhas, separada por vírgulas ou valores com aspas que colam direto no código
- Ilimitado e gratuito: sem registos, sem limites de utilização, nada nos nossos servidores
Os UUIDs aparecem sempre que algo tem de ser nomeado antes de se poder confirmar que o nome está livre. O código da aplicação cunha-os para as linhas que está prestes a inserir, para que o objeto tenha uma identidade antes de chegar à base de dados e o cliente o possa referenciar enquanto a gravação ainda está em curso. Os sistemas distribuídos apoiam-se neles ainda mais: vários serviços de um portal digital do Estado a escrever na mesma tabela, uma aplicação de pagamentos a criar registos enquanto está offline, ou uma fila de mensagens de um banco que tem de reconhecer a transferência que já processou — nenhum destes casos pode esperar a sua vez por um contador partilhado. A versão 5 cobre uma necessidade diferente, que é um identificador estável derivado de algo que já se tem: o mesmo documento clínico de um grupo de investigação, a mesma fatura de uma empresa que serve clientes por toda a Europa ou a mesma conta mapeia sempre para o mesmo UUID, pelo que uma importação pode correr duas vezes sem duplicar nada. Noutros locais, são simplesmente o formato que um sistema exige — um identificador de correlação encadeado em registos e traces, um nome de ficheiro que não vai colidir quando os carregamentos de mil utilizadores caírem no mesmo bucket, uma chave de registo do Windows, ou um fixture de teste que precisa de parecer dados reais.
Alguns limites honestos valem a pena conhecer. Um lote é de uma única versão: o valor em «Versão» aplica-se a tudo o que lá está, pelo que uma execução de v4 e uma execução de v7 são dois lotes separados. Este é um gerador, não um inspetor — colar um UUID aqui para ler a sua versão ou o seu carimbo de data/hora não é algo que esta página faça. «Guardar em ficheiro» escreve um ficheiro de texto simples em vez de CSV ou JSON. A versão 7 revela abertamente quando foi criada, ao milissegundo, o que é uma contrapartida real em vez de uma falha, e a versão 1 deixa vazar o tempo da mesma maneira; se isso for um problema para os dados, a versão 4 é a versão que não diz nada a ninguém. Dois valores especiais da norma não são versões e por isso não são opções em «Versão», mas é possível copiá-los daqui: o nil UUID, 00000000-0000-0000-0000-000000000000, e o max UUID, ffffffff-ffff-ffff-ffff-ffffffffffff. Tudo nesta página segue a RFC 9562, a especificação que substituiu a RFC 4122 em 2024, pelo que o output é aceite por qualquer biblioteca, base de dados ou API que lide sequer com UUIDs. Dentro destes limites, a garantia é forte: cada identificador é construído de acordo com a norma, a partir de aleatoriedade criptograficamente segura, na própria máquina do utilizador, e mais ninguém os vê.