Ferramenta online de gerador UUID

1. 1

   Escolha a versão do UUID

   A versão 4 é aleatória e a opção segura por padrão. A versão 7 é ordenada no tempo e é melhor para uma chave de banco de dados. As versões 3 e 5 transformam um nome num identificador que nunca muda. As versões 1 e 6 incorporam uma data, e Nil e Max são os dois valores especiais fixos.

2. 2

   Defina quantos precisa

   Digite um número ou use uma predefinição. Cem por clique são gratuitos; lotes maiores, até um milhão de cada vez, são o campo do Pro. Nas versões 3 e 5 a quantidade vem da lista de nomes que colar.

3. 3

   Escolha o aspeto

   Alterne entre minúsculas e maiúsculas, retire os hífenes para a forma compacta, envolva os valores em chaves ou no prefixo urn:uuid:, e acrescente um prefixo ou sufixo se for colar diretamente em código.

4. 4

   Gere

   Pressione o botão de gerar. Cada valor é produzido no seu dispositivo a partir da respetiva fonte criptográfica de aleatoriedade, sem enviar nada para um servidor.

5. 5

   Copie ou exporte

   Copie um valor com o botão ao lado, copie o lote inteiro de uma vez, ou transfira a lista como texto simples, JSON, CSV ou Base64.

6. 6

   Verifique identificadores que já tem

   Mude para o modo Verificar e cole uma lista, ou solte um arquivo de texto, CSV, JSON ou de registro. Cada valor é apresentado com a sua versão, variante, hora de criação incorporada e nó, e os duplicados são contados.

O RFC 9562 substituiu o RFC 4122 em maio de 2024 e acrescentou três versões novas e dois valores especiais. Esta página gera todas as que um navegador pode produzir honestamente. Cada entrada diz o que o valor contém e a situação de que é a resposta certa.

• Versão 4 — aleatória — 122 bits de aleatoriedade e mais nada. Imprevisível, não transporta informação sobre quando ou onde foi criada, e é a opção certa por padrão sempre que não tiver qualquer requisito para além da unicidade.
• Versão 7 — ordenada no tempo — Uma data de 48 bits em milissegundos seguida de aleatoriedade. Ordena-se por data de criação como simples string, o que a torna a recomendação moderna para chaves primárias. Nova no RFC 9562.
• Versão 1 — baseada no tempo — Uma data de 60 bits contada em intervalos de 100 nanossegundos desde 1582, mais uma sequência de relógio e um nó. Muito suportada e muito implantada, mas a ordem dos seus campos faz com que as strings não se ordenem no tempo.
• Versão 6 — baseada no tempo, reordenada — Os mesmos três campos da versão 1, guardados começando pelo mais significativo para que as strings se ordenem. Pensada como substituta direta da versão 1 em sistemas que não podem passar para a versão 7.
• Versão 3 — espaço de nomes com MD5 — Uma dispersão de um espaço de nomes e de um nome. Determinística: as mesmas entradas dão sempre o mesmo identificador. Mantida por compatibilidade com sistemas que já a usam.
• Versão 5 — espaço de nomes com SHA-1 — A mesma ideia da versão 3 com outra função de dispersão, e a que se deve escolher para novos identificadores determinísticos.
• Nil — Trinta e dois zeros. Um valor especial definido, não uma versão, e por convenção significa a ausência de identificador.
• Max — Trinta e dois caracteres f. O outro valor especial definido, e o maior que um UUID pode ser: útil como limite superior de um intervalo.

A versão 2 está definida mas não é gerada aqui, e isso é deliberado e não um esquecimento. Reserva os 32 bits baixos da data para um identificador de usuário ou grupo POSIX, que uma página web não pode conhecer, por isso todos os geradores de versão 2 online produzem algo estruturalmente correto e semanticamente vazio. A versão 8 está reservada para disposições experimentais e próprias de cada fabricante, e não tem um significado fixo contra o qual gerar.

É esta a decisão com que as pessoas realmente chegam, e tem uma resposta clara que mudou nos últimos dois anos.

• Use a versão 7 — para qualquer chave primária nova. Os seus valores crescem no tempo, por isso cada inserção cai no fim do índice e não num ponto aleatório do meio.
• O problema das chaves da versão 4 — não é a unicidade, é a localidade de escrita. Chaves aleatórias espalham as inserções por toda a árvore B, por isso as páginas escritas ficam repartidas pelo índice e as de que precisa têm menos probabilidade de estar em memória. Numa tabela grande e movimentada isso traduz-se em inserções mais lentas e num índice maior.
• Não use a versão 1 para isto — mesmo sendo baseada no tempo. O seu campo de data menos significativo vem primeiro, por isso as strings não se ordenam por criação e, para o índice, comporta-se como uma chave aleatória.
• Armazene-as de forma compacta se puder — Um UUID tem 16 bytes; escrito com hífenes tem 36. Os bancos de dados que oferecem uma coluna UUID nativa ou binary(16) usam um quarto do espaço de um char(36) e comparam mais depressa.
• Seja coerente com a caixa e os hífenes — Dois serviços que guardem o mesmo identificador em formas diferentes não coincidem numa comparação de strings. Escolha uma representação na fronteira e normalize à entrada.

Todas as configurações desta página são gratuitas, e só o tamanho do lote tem uma fronteira de plano. Os controles dividem-se em dois grupos que se comportam de forma diferente: mudar uma definição de geração produz identificadores novos, enquanto mudar uma definição de formato apenas altera a forma como os já apresentados são escritos.

Versão

Escolhe que tipo de identificador é produzido. É uma definição de geração, por isso mudá-la substitui os valores na tela em vez de os reformatar. A dica sob o seletor muda com a sua escolha e diz numa linha para que serve essa versão.

Quantos

Digite um número ou clique em uma predefinição. A caixa não aceita um valor acima do limite do seu plano, por isso nunca pode pedir um lote que a ferramenta depois recuse — um controle que oferece um valor impossível é pior do que um que não o oferece. Nas versões 3 e 5 esta caixa é substituída pela lista de nomes, porque aí a quantidade é o número de nomes que fornecer.

Caixa, hífenes, chaves e URN

Puramente de apresentação, e aplicado sem regenerar nada. A forma compacta retira os quatro hífenes e é o que muitos bancos de dados guardam internamente. As chaves são a forma como o SQL Server e as APIs antigas do Windows escrevem um GUID. O prefixo urn:uuid: é a forma que o RFC 9562 define para uso como URI. As quatro opções combinam-se.

Prefixo e sufixo

Envolve cada linha com texto seu, que é a diferença entre uma lista que se copia e uma lista que se cola. Pôr INSERT INTO usuários (id) VALUES (' como prefixo e '); como sufixo transforma um lote em SQL executável. Os acréscimos entram em todos os formatos de exportação, e o CSV coloca-os corretamente entre aspas se contiverem uma vírgula.

Formato de exportação

Texto simples dá um valor por linha. Separado por vírgulas encaixa numa cláusula IN. JSON é um array pronto a usar. CSV traz uma linha de cabeçalho e, quando a versão a tem, uma coluna de nome ou de hora de criação ao lado de cada valor. Base64 codifica a lista inteira, para os lugares que querem um bloco opaco.

Mude para o modo Verificar e cole o que quiser: uma coluna de uma exportação de banco de dados, um arquivo de registro, um corpo JSON, um único valor de um relatório de erro. Cada token com forma de UUID é encontrado e descrito, em qualquer mistura de formatos e caixas, e também pode soltar um arquivo.

• Versão e variante — Ambas, e não são a mesma pergunta. A variante decide se o dígito de versão significa alguma coisa.
• Hora de criação — Nas versões 1, 6 e 7 a data incorporada é convertida numa data legível. Costuma ser a forma mais rápida de saber quando um registro foi criado se ninguém guardou um created_at.
• Sequência de relógio e nó — Nas versões 1 e 6, juntamente com a indicação de se o nó é um valor aleatório ou um endereço de rede real: o bit de multidifusão di-lo, e um valor com endereço real foi criado por algo com acesso a uma placa de rede.
• Formato — Com hífenes, compacto, entre chaves ou com prefixo urn:uuid:, indicado valor a valor, para que uma lista que mistura representações seja fácil de detectar.
• Duplicados — Contados em toda a lista. É a única estatística que vale a pena numa lista colada e a que nada significa numa saída acabada de gerar.

Por que alguns valores são não normalizados em vez de inválidos

O primeiro dígito do quarto grupo transporta os bits de variante. Só o padrão 10xx marca um identificador do RFC 9562; 110x é um GUID COM da Microsoft, 0xxx é um valor NCS herdado e 111x está reservado. Se a variante não for a do RFC, o dígito de versão é um dado vulgar e apresentá-lo como versão inventa informação que não existe. Um valor como 00000000-0000-9000-0000-000000000000 tem trinta e dois dígitos hexadecimais válidos e nenhuma versão: os verificadores que anunciam uma versão 9 estão lendo um dígito e a chamar-lhe fato.

Estas duas são as exceções: não são aleatórias e não têm que ver com o tempo. Transformam um espaço de nomes e um nome num identificador por dispersão, e o mesmo par produz sempre o mesmo resultado.

• Escolha um espaço de nomes — O RFC 9562 define quatro pelo nome: DNS para nomes de host, URL para endereços, OID para identificadores de objeto e X500 para nomes de diretório. Qualquer UUID pode servir de espaço de nomes, por isso um projeto pode definir o seu e obter um espaço de identificadores privado.
• Cole os nomes — Um por linha. Cada um produz um identificador, e a quantidade vem da lista e não da caixa do lote.
• A reprodutibilidade é o objetivo — Voltar a correr a mesma lista no próximo ano noutra máquina dá os mesmos identificadores, e é isso que os torna úteis para reconciliar registros entre sistemas que não compartilham banco de dados.
• Não é uma função de segurança — MD5 e SHA-1 estão ambos quebrados como funções de dispersão criptográficas. O RFC 9562 mantém-nos aqui porque a saída é um identificador e não um autenticador, e di-lo explicitamente. Nunca trate um valor da versão 3 ou 5 como impossível de adivinhar.

O número é suficientemente grande para que a intuição não ajude muito, por isso aqui fica em concreto.

• Um UUID tem 128 bits. A versão 4 fixa seis deles para a versão e a variante, deixando 122 bits de aleatoriedade: cerca de 5,3 sextiliões de valores possíveis.
• Para chegar a uma probabilidade de um em mil milhões de uma única colisão precisaria da ordem de cem mil milhões de identificadores. A um milhão por segundo são cerca de três anos de geração contínua.
• A falha realista nunca é a matemática, é uma fonte de aleatoriedade fraca. Esta página usa o gerador criptográfico do navegador, a mesma fonte usada para chaves de sessão, e nunca uma simples função pseudoaleatória.
• A versão 7 sacrifica alguma aleatoriedade a favor da ordem: 74 bits aleatórios por valor em vez de 122. Continua muito para lá de qualquer risco prático de colisão, e a troca é precisamente o sentido da versão.
• As versões 3 e 5 são determinísticas, por isso entradas idênticas devem colidir. Isso é a funcionalidade, não um defeito.

A maior parte dos problemas que as pessoas têm com UUIDs vem de esperar que uma destas quatro coisas seja verdade.

• Não é um segredo — Os identificadores acabam em URLs, registros, relatórios de erro e análises. As versões 1, 6 e 7 declaram ainda quando foram criadas. Autorize cada pedido; possuir um id nunca deve ser a verificação.
• Não é ordenável, a menos que tenha escolhido uma versão que o seja — As versões 4, 3 e 5 não têm ordem nenhuma, e a versão 1 apenas aparenta ter. Se precisa da ordem de criação a partir da própria chave, isso significa versão 7 ou versão 6.
• Não é gratuito como chave — Dezasseis bytes contra quatro de um inteiro, e trinta e seis se for armazenado como string. Numa tabela com vários índices essa diferença é real, e é a razão para os guardar numa coluna nativa ou binária.
• Não substitui uma chave natural — Um UUID diz que dois registros são diferentes. Nunca diz que dois registros são a mesma coisa, que é o que faz uma verdadeira chave de negócio.

O tamanho do lote é a única definição desta página com um plano associado. Todas as versões, todas as opções de formato e todos os formatos de exportação funcionam igual nos dois planos.

O que o plano gratuito inclui

Os oito tipos de identificador, toda a formatação, os cinco formatos de exportação, o verificador completo com relatório CSV, e cem identificadores por clique. Chega para dados de teste, uma fixture, um punhado de chaves, ou para ver o que está dentro de um id que alguém lhe enviou.

O que o Pro acrescenta

Lotes maiores — mil, dez mil, cem mil ou um milhão de cada vez — e até vinte e cinco arquivos de lista ao mesmo tempo do lado da verificação. Um milhão de identificadores é o ponto em que o limite passa a ser o navegador e não o plano, e a partir daí é avisado em vez de recusado.

Medido em Chromium num computador de secretária: cem mil identificadores da versão 4 são produzidos em cerca de 20 milissegundos, cem mil valores colados são analisados em menos de um décimo de segundo, e exportar cem mil como CSV demora cerca de 4 milissegundos. Apenas os primeiros duzentos valores são desenhados na tela, e é por isso que um lote de um milhão continua aparecendo instantaneamente.

Um gerador de identificadores que chama um servidor exige confiar duas vezes: em que produz bons valores e em que não os guarda. Este elimina a segunda pergunta porque não envia nada.

• Nada é enviado — Nem os identificadores, nem os nomes que cola para as versões 3 e 5, nem a lista que larga para verificar. Abra o painel de rede do seu navegador enquanto usa a página e não há nada para ver.
• Funciona offline — Depois de a página carregar, gerar e verificar continuam funcionando sem nenhuma conexão — útil numa rede restrita ou num avião.
• A fonte de aleatoriedade é a do próprio navegador — O mesmo gerador criptográfico que o navegador usa para as suas chaves, obtido em blocos e formatado depois, que é o que torna rápido um lote grande sem o enfraquecer.

As versões 2 e 8 não são geradas, pelas razões dadas acima. As versões 3 e 5 dependem de MD5 e SHA-1, quebrados criptograficamente e usados aqui apenas pelo seu determinismo. O verificador lê quaisquer 32 dígitos hexadecimais em qualquer invólucro habitual, mas não lhe pode dizer se um identificador foi mesmo emitido pelo seu sistema: apenas o que contém. Tudo nesta página funciona nas versões atuais do Chrome, Edge, Firefox e Safari, em computador e em celular.

• Gerador de hash
• Codificador/descodificador Base64
• Codificador/descodificador de URL
• Gerador de códigos QR
• Gerador de códigos de barras
• Formatador JSON
• Conversor de cores
• Gerador de paletas de cores
• Conversor de data e hora
• Validador JSON
• CSV para JSON
• Remover linhas duplicadas
• Remover linhas duplicadas (texto)
• Dividir texto
• Ordenar texto
• Conversor de maiúsculas
• Todos os conversores