Como gerar UUIDs em Rust

UUIDs (Universally Unique Identifiers) são um meio confiável de identificar exclusivamente objetos em sistemas distribuídos, uma vez que eliminam a necessidade de coordenação centralizada. Os UUIDs aprimoram a integridade dos dados e promovem a interoperabilidade entre sistemas com sua singularidade e natureza resistente a colisões.

Rust é popular em áreas onde identificadores únicos são essenciais, incluindo redes, construção de aplicações web e sistemas distribuídos; existem muitas caixas para gerar e personalizar UUIDs com Rust, além disso, você pode escrever código Rust para executar o uuid comando em sua máquina e recupere um UUID.

Gerando UUIDs com o uuid Crate

O uuid A caixa é a ferramenta mais popular para gerar UUIDs em Rust.

Adicione o uuid crate como uma das dependências do seu projeto em seu Cargo.toml arquivo:

[dependências]
uuid = { versão = "0.8", características = ["serde", "v4"] }

Gerar UUIDs com o pacote é simples. Você pode usar o new_v4 função para gerar uma versão quatro UUID:

usar uuid:: Uuid;
fnprincipal() {
// new_v4 gera uma versão 4 UUID
deixar my_uuid = Uuid:: new_v4();
println!("{}", meu_uuid);
}

O principal A função gera um novo UUID com o new_v4 função e imprime o UUID no console com o println! macro.

Você pode personalizar sua geração de UUID com o Construtor e Versão módulos do uuid caixotes.

Veja como você pode gerar um RFC4122 UUID de uma versão aleatória com o uuid caixote:

// Importa os módulos necessários da caixa uuid
usar uuid::{Construtor, Versão};
fnprincipal() {
// Cria um novo Builder e inicializa-o com um array de 16 zero bytes
deixar uuid_result = Construtor:: from_bytes([0; 16])
// Define a versão do UUID para Random
 .set_version (Versão:: Aleatório)
// Defina a variante UUID para RFC4122
 .set_variant (uuid:: Variante:: RFC4122)
// Constrói o UUID
 .construir();
// Imprime o UUID personalizado em formato hifenizado
println!("UUID personalizado: {}", uuid_result.to_hyphenated());
}

O principal função gera o UUID com um novo Construtor instância criada com o from_bytes função que recebe uma matriz de dezesseis bytes como argumento (neste caso, uma matriz de zeros). O construtor configura a geração UUID definindo a versão como Aleatório e a variante para RFC4122.

finalmente, o principal função constrói o UUID com o construir chamada de método no construtor e imprime o UUID no console.

Gerando UUIDs executando o comando UUID

você pode não precisar dependências de terceiros em Rust para gerar UUIDs, especialmente se você não pretende personalizar o UUID com base no seu caso de uso. A maioria dos sistemas operacionais possui uma ferramenta de geração de UUID instalada que a maioria dos aplicativos chama para gerar UUIDs. Você pode escrever código Rust para executar a ferramenta de linha de comando UUID e recuperar o UUID para o seu programa.

Você pode usar o built-in do Rust std:: processo:: Comando módulo para gerar e interagir com novos processos. Para gerar UUIDs com o Comando módulo, você precisará identificar o nome da ferramenta de geração de UUID em seu sistema operacional. No macOS, a ferramenta de geração de UUID é chamada uuigen.

Veja como você pode gerar e recuperar UUIDs do seu código Rust executando o uuidgen comando com o Comando módulo:

usar std:: processo:: Comando;
fngerar_uuid() -> Resultado<Corda, std:: io:: Erro> {
deixar saída = Comando:: novo("uuidgen").saída()?;
deixar uuid = Corda::from_utf8_lossy(&output.stdout).into_owned();
OK(uuid)
}
fnprincipal() {
corresponder gerar_uuid() {
OK(uuid) => println!("UUID gerado: {}", uuid),
Errar(e) => eprintln!("Erro ao gerar UUID: {}", e),
 }
}

O gerar_uuid A função retorna a versão de string do UUID e um erro. O gerar_uuid A função gera um novo processo com o novo método do Comando módulo, recupera a saída com o saída função e converte o UUID em uma string com o from_utf8_lossy função.

O principal função chama o gerar_uuid função com uma instrução de correspondência, lida com o erro, e gera o UUID ou uma mensagem de erro com base no status da operação.

Você pode criar aplicativos da Web sofisticados com Rust

UUIDs são muito importantes no desenvolvimento de software moderno. A maioria de seus aplicativos diários usa UUIDs e as ferramentas de geração de UUID são instaladas na maioria dos sistemas operacionais, incluindo Microsoft Windows, Linux e macOS.

Você pode usar UUIDs para identificar usuários de seus aplicativos da web. Essa é uma ótima maneira de garantir que os usuários tenham um identificador exclusivo que possam usar para rastrear suas atividades. Além disso, você pode usar UUIDs para identificar outros objetos em seu aplicativo da web, de arquivos a documentos e produtos.