Como construir um aplicativo CLI básico em Rust

CLI (Command Line Interfaces) é crucial no desenvolvimento de software e administração do sistema. CLIs são programas leves baseados em texto que oferecem uma maneira simplificada de interagir com computadores que são favoráveis para desenvolvedores e usuários avançados para vários casos de uso, incluindo automação, script e controle remoto administração.

Rust está ganhando popularidade para criar aplicativos CLI. O Rust fornece recursos poderosos, como controle refinado sobre alocação de memória e segurança de thread, segurança de memória, simultaneidade e paralelismo que você pode aproveitar para criar aplicativos CLI poderosos. Rust também se orgulha de um próspero ecossistema de bibliotecas e estruturas adaptadas explicitamente para a criação de aplicativos CLI.

Introdução à criação de aplicativos CLI com Rust

Existem vários pacotes de terceiros para criar aplicativos CLI em Rust, incluindo

Aplaudir, StructOpt, e termião caixotes. Essas caixas fornecem os recursos necessários para desenvolver ferramentas CLI modernas.

Além disso, Rust fornece uma padrão:: ambiente crate em sua biblioteca padrão que fornece funcionalidade para trabalhar com variáveis ​​de ambiente e argumentos de linha de comando. O padrão:: ambiente A caixa oferece uma variedade de métodos e tipos para trabalhar com ambientes de maneira independente de plataforma.

Usando o padrão:: ambiente caixa, seus programas Rust podem interagir com o ambiente e adaptar seu comportamento com base em vários fatores, incluindo variáveis ​​de ambiente, argumentos de linha de comando e o funcionamento atual diretório.

Execute este comando para criar um novo projeto Rust para seu aplicativo CLI com Cargo, a ferramenta de gerenciamento de pacotes do Rust:

carga nova crypto_cli

Você aprenderá como criar um aplicativo CLI que chama a API do Coinmarketcap com o Solicitar caixa que fornece recursos para fazer Solicitações HTTP em Rust.

Abre o teu Cargo.toml arquivo e adicione o pedir e Tóquio crates para as dependências do seu projeto:

[dependências]
Tóquio = { versão = "1.15", características = ["completo"] }
pedir = { versão = "0.11", características = ["json"] }
serde = { versão = "1.0", características = ["derivar"] }
serde_json = "1.0"

O Tóquio crate é uma biblioteca de tempo de execução assíncrona que interopera com pedir para programação assíncrona. O serde e serde_json caixotes ajudam com Serialização e desserialização JSON.

No origem pasta do seu projeto Rust, crie api.rs e cli.rs arquivos onde você implementará a chamada de API e as funcionalidades da CLI.

toque em src/api.rs src/cli.rs

O comando deve criar os arquivos desejados no diretório de trabalho do seu projeto. Depois de escrever as funcionalidades em seus arquivos designados para separação de preocupações, você chamará as funções no principal função em seu principal.rs arquivo.

Fazendo solicitações de API para a API do CoinMarketCap com Reqwest

API do CoinMarketCap permite que você acesse e integre dados de criptomoeda em seus aplicativos. A API fornece terminais para listagens, cotações de mercado, informações de câmbio, ferramentas de conversão, dados históricos e metadados.

Ao fazer login, você pode se inscrever em uma conta CoinMarketCap e recuperar sua chave de API na página do desenvolvedor do Coinmarketcap. Você também pode consultar a documentação para obter instruções detalhadas e limites de taxa.

Para fazer uma solicitação de API para o /v2/cryptocurrency/quotes/latest endpoint que retorna a cotação de mercado mais recente para uma ou mais criptomoedas, você terá que definir o structs para os dados que você deseja extrair da API e especifique os atributos com a característica derivada de Serde.

Em seguida, você pode solicitar uma API para o endpoint e usar o serde_json crate para desserializar os dados JSON na estrutura para operações mais fáceis em tipos de dados Rust.

Aqui está o definição de estrutura que recupera o eu ia, nome, símbolo, e citar dados das criptomoedas especificadas

#[derivar (depurar, desserializar, serializar)]
estruturaApiResponse {
 dados: Dados,
}
#[derivar (depurar, desserializar, serializar)]
estruturaDados {
// Adicione os campos que você precisa do objeto de dados
#[serde (renomear = "1")]
 crypto_1: Criptomoeda,
#[serde (renomear = "2")]
 crypto_2: Criptomoeda,
#[serde (renomear = "3")]
 crypto_3: Criptomoeda,
#[serde (renomear = "4")]
 crypto_4: Criptomoeda,
}
#[derivar (depurar, desserializar, serializar)]
estruturaCriptomoeda {
 eu ia: u32,
 nome: Corda,
 símbolo: Corda,
// Adicione outros campos conforme necessário
 Citação: Citação,
}
#[derivar (depurar, desserializar, serializar)]
estruturaCitar {
 USD: detalhes da cotação,
}
#[derivar (depurar, desserializar, serializar)]
estruturaCotaçãoDetalhes {
 preço: f64,
 volume_24h: f64,
// Adicione outros campos conforme necessário
}

A API retorna dados que podem ser mais do que você precisa, mas com o serde crate, você pode especificar os dados exatos de que precisa, conforme mostrado acima.

Agora, você pode solicitar o endpoint com Reqwest criando um novo cliente que faça a solicitação GET com os parâmetros necessários.

usar requisição:: Cliente;
usar requisição:: Erro;
barassíncronofncripto() -> Resultado {
deixar cliente = Cliente:: new();
deixar URL = " https://pro-api.coinmarketcap.com/v2/cryptocurrency/quotes/latest";
deixar parâmetros = [
 ("eu ia", "1,2,3,4"),
 ("converter", "USD"), // Converte valores de mercado para USD
 ];
deixar resposta = cliente.get (url)
 .cabeçalho("X-CMC_PRO_API_KEY", "SUA CHAVE DE API AQUI")
 .query(&params)
 .enviar().aguardam?;
 ;
deixar resultado: ApiResponse = serde_json:: from_str(&*response.text().aguardam?;).desembrulhar();
println!("{:#?}", resultado);
OK(())
}

O cripto function é uma função assíncrona habilitada para tokio que solicita o endpoint com o cliente.obter função depois de criar uma instância de cliente com o Cliente:: novo método.

O cabeçalho chamada de função na instância do construtor de solicitação leva em sua chave de API, o consulta função recebe os parâmetros, e o enviar A função envia a solicitação.

O cripto função desserializa a resposta JSON com serde_json's from_str método que recebe uma string JSON.

finalmente, o cripto A função imprime o resultado da operação de desserialização no console.

Recuperando argumentos CLI em Rust

Na tua cli.rs arquivo, você vai importar o cripto função do api.rs arquivo e chame a função se o usuário digitar “crypto” como argumento ao executar o projeto com o corrida de carga comando.

Veja como você pode usar o padrão:: ambiente função para recuperar o argumento da linha de comando:

usar padrão:: env;
usar caixa:: api:: cripto;
barassíncronofncli() {
deixar argumentos: vec<Corda> = env:: args().collect();
se args.len() > 1 && argumentos[1] == "cripto" {
 cripto().aguardam.desembrulhar();
 } outro {
println!("Comando inválido. Uso: carga run crypto");
 }
}

O cli função recupera todos os argumentos da linha de comando com o env:: args().collect() função. O if-else A instrução verifica se há um argumento adicional, "crypto". Se a condicional for verdadeira, o cli função chama o cripto função; caso contrário, o cli A função imprime uma string no console.

Finalmente, você pode ligar para o cli função no principal função. Você deve adicionar o #[tóquio:: principal] atributo desde principal as funções não podem ser assíncronas no Rust.

mod API;
mod cli;
usar caixa:: cli:: cli;
#[tóquio:: principal]
assíncronofnprincipal() {
 cli().aguardam;
}

O principal função chama o cli funcionar com o aguardam função que suspende a execução até o resultado de um Futuro está pronto.

Aqui está o resultado da execução do criptografia de corrida de carga comando:

Você pode criar aplicativos da Web sofisticados em Rust

Rust é uma linguagem de programação versátil com muitos casos de uso e aplicações. Você pode aproveitar estruturas da Web de terceiros, como Actix, Rocket e Warp, para criar aplicativos da Web em Rust. Essas estruturas fornecem a maioria das funcionalidades necessárias para criar aplicativos da Web modernos.