Hur man bygger en grundläggande CLI-app i Rust

CLI (Command Line Interfaces) är avgörande för mjukvaruutveckling och systemadministration. CLI: er är lätta textbaserade program som erbjuder ett strömlinjeformat sätt att interagera med datorer som är gynnsamma för både utvecklare och avancerade användare för flera användningsfall, inklusive automatisering, skript och fjärrkontroll administrering.

Rust blir allt mer populärt för att bygga CLI-appar. Rust ger kraftfulla funktioner som finkornig kontroll över minnesallokering och trådsäkerhet, minnessäkerhet, samtidighet och parallellitet som du kan utnyttja för att bygga kraftfulla CLI-appar. Rust har också ett blomstrande ekosystem av bibliotek och ramverk som är specifikt skräddarsydda för att bygga CLI-applikationer.

Komma igång Bygga CLI-appar med rost

Det finns flera tredjepartspaket för att bygga CLI-appar i Rust, inklusive Klappa, StructOpt, och Termion lådor. Dessa lådor ger de funktioner du behöver för att utveckla moderna CLI-verktyg.

Rust ger också en std:: env crate i sitt standardbibliotek som ger funktionalitet för att arbeta med miljövariabler och kommandoradsargument. De std:: env crate erbjuder en rad metoder och typer för att arbeta med miljöer på ett plattformsoberoende sätt.

Använda std:: env låda kan dina Rust-program interagera med miljön och anpassa sitt beteende utifrån olika faktorer, inklusive miljövariabler, kommandoradsargument och det aktuella arbetet katalog.

Kör det här kommandot för att skapa ett nytt Rust-projekt för din CLI-app med Cargo, Rusts pakethanteringsverktyg:

last ny crypto_cli

Du lär dig hur du bygger en CLI-applikation som anropar Coinmarketcaps API med Reqwest låda som ger funktioner för tillverkning HTTP-förfrågningar i Rust.

Öppna din Cargo.toml fil och lägg till reqwest och tokio lådor till ditt projekts beroenden:

[beroenden]
tokio = { version = "1.15", funktioner = ["full"] }
reqwest = { version = "0.11", funktioner = ["json"] }
serde = { version = "1.0", funktioner = ["härleda"] }
serde_json = "1.0"

De tokio crate är ett asynkront runtime-bibliotek som samverkar med reqwest för asynkron programmering. De serde och serde_json lådor hjälper till med JSON-serialisering och deserialisering.

I den src mapp för ditt Rust-projekt, skapa api.rs och kli.rs filer där du ska implementera API-anropet och CLI-funktionerna.

tryck på src/api.rs src/cli.rs

Kommandot ska skapa de önskade filerna i ditt projekts arbetskatalog. Efter att ha skrivit funktionerna i deras utsedda filer för separation av bekymmer, anropar du funktionerna i huvud funktion i din main.rs fil.

Gör API-förfrågningar till CoinMarketCaps API med Reqwest

CoinMarketCaps API låter dig komma åt och integrera kryptovalutadata i deras applikationer. API: et tillhandahåller slutpunkter för listor, marknadsnoteringar, utbytesinformation, konverteringsverktyg, historisk data och metadata.

När du loggar in kan du registrera dig för ett CoinMarketCap-konto och hämta din API-nyckel på Coinmarketcaps utvecklarsida. Du kan också hänvisa till dokumentationen för detaljerade instruktioner och prisgränser.

För att göra en API-begäran till /v2/cryptocurrency/quotes/latest slutpunkt som returnerar den senaste marknadsnoteringen för en eller flera kryptovalutor, måste du definiera strukturer för de data du vill extrahera från API: t och specificera attributen med Serdes härledande egenskap.

Sedan kan du begära ett API till slutpunkten och använda serde_json crate för att deserialisera JSON-data till strukturen för enklare operationer på Rust-datatyper.

Här är strukturdefinition som hämtar id, namn, symbol, och Citat data för de angivna kryptovalutorna

#[derive (Debug, Deserialize, Serialize)]
strukturApiResponse {
 data: data,
}
#[derive (Debug, Deserialize, Serialize)]
strukturData {
// Lägg till fält som du behöver från dataobjektet
#[serde (byt namn på = "1")]
 krypto_1: Kryptovaluta,
#[serde (byt namn på = "2")]
 krypto_2: Kryptovaluta,
#[serde (byt namn på = "3")]
 krypto_3: Kryptovaluta,
#[serde (byt namn på = "4")]
 krypto_4: Kryptovaluta,
}
#[derive (Debug, Deserialize, Serialize)]
strukturKryptovaluta {
 id: u32,
 namn: Sträng,
 symbol: Sträng,
// Lägg till andra fält efter behov
 citat: Citat,
}
#[derive (Debug, Deserialize, Serialize)]
strukturCitat {
 USD: QuoteDetails,
}
#[derive (Debug, Deserialize, Serialize)]
strukturCitat Detaljer {
 pris: f64,
 volym_24h: f64,
// Lägg till andra fält efter behov
}

API: et returnerar data som kan vara mer än du behöver, men med serde crate, kan du ange exakt vilken data du behöver, som visas ovan.

Nu kan du begära slutpunkten med Reqwest genom att skapa en ny klient som gör GET-begäran med de nödvändiga parametrarna.

använda sig av reqwest:: Klient;
använda sig av reqwest:: Fel;
pubasynkronfnkrypto() -> Resultat {
låta klient = Klient:: new();
låta url = " https://pro-api.coinmarketcap.com/v2/cryptocurrency/quotes/latest";
låta params = [
 ("id", "1,2,3,4"),
 ("konvertera", "USD"), // Konvertera marknadsvärden till USD
 ];
låta respons = client.get (url)
 .rubrik("X-CMC_PRO_API_KEY", "DIN API-NYCKEL HÄR")
 .query(&params)
 .skicka().vänta?;
 ;
låta resultat: ApiResponse = serde_json:: from_str(&*response.text().vänta?;).packa upp();
println!("{:#?}", resultat);
Ok(())
}

De krypto funktion är en tokio-aktiverad asynkron funktion som begär slutpunkten med klient.get funktion efter att ha skapat en klientinstans med Kund:: ny metod.

De rubrik funktionsanrop på begäranbyggarinstansen tar in din API-nyckel, den fråga funktionen tar in parametrarna och skicka funktionen skickar begäran.

De krypto funktion avserialiserar JSON-svaret med serde_jsons from_str metod som tar in en JSON-sträng.

Slutligen, den krypto funktionen skriver ut resultatet av deserialiseringsoperationen till konsolen.

Hämtar CLI-argument i Rust

I din kli.rs fil importerar du krypto funktion från api.rs fil och anropa funktionen om användaren artar "krypto" som ett argument för att köra projektet med lastkörning kommando.

Så här kan du använda std:: env funktion för att hämta argumentet från kommandoraden:

använda sig av std:: env;
använda sig av låda:: api:: krypto;
pubasynkronfncli() {
låta args: Vec<Sträng> = env:: args().collect();
om args.len() > 1 && args[1] == "krypto" {
 krypto().vänta.packa upp();
 } annan {
println!("Ogiltigt kommando. Användning: cargo run crypto");
 }
}

De cli funktionen hämtar alla argument från kommandoraden med env:: args().collect() fungera. De om annat uttalande kontrollerar om det finns ett ytterligare argument, "krypto". Om det villkorade utvärderas sant, cli funktionen anropar krypto fungera; annars, den cli funktionen skriver ut en sträng till konsolen.

Slutligen kan du ringa till cli funktion i huvud fungera. Du måste lägga till #[tokio:: main] attribut sedan huvud funktioner kan inte vara asynkrona i Rust.

mod api;
mod cli;
använda sig av låda:: cli:: cli;
#[tokio:: main]
asynkronfnhuvud() {
 cli().vänta;
}

De huvud funktionen anropar cli funktion med vänta funktion som avbryter exekvering tills resultatet av en Framtida är redo.

Här är resultatet av att köra cargo run krypto kommando:

Du kan bygga sofistikerade webbappar i Rust

Rust är ett mångsidigt programmeringsspråk med många användningsfall och applikationer. Du kan utnyttja webbramverk från tredje part som Actix, Rocket och Warp för att bygga webbapplikationer i Rust. Dessa ramverk tillhandahåller de flesta funktioner som behövs för att bygga moderna webbappar.