Sådan bygger du en grundlæggende CLI-app i Rust

CLI (Command Line Interfaces) er afgørende i softwareudvikling og systemadministration. CLI'er er lette tekstbaserede programmer, der tilbyder en strømlinet måde at interagere med computere på, som er gunstige til både udviklere og superbrugere til flere anvendelsessager, inklusive automatisering, scripting og fjernbetjening administration.

Rust vinder popularitet for at bygge CLI-apps. Rust giver kraftfulde funktioner som finkornet kontrol over hukommelsesallokering og trådsikkerhed, hukommelsessikkerhed, samtidighed og parallelitet, som du kan udnytte til at bygge kraftfulde CLI-apps. Rust kan også prale af et blomstrende økosystem af biblioteker og rammer, der er skræddersyet eksplicit til at bygge CLI-applikationer.

Kom godt i gang med at bygge CLI-apps med rust

Der er flere tredjepartspakker til at bygge CLI-apps i Rust, bl.a Klappe, StructOpt, og Termion kasser. Disse kasser giver de funktioner, du skal bruge for at udvikle moderne CLI-værktøjer.

Rust giver også en std:: env kasse i sit standardbibliotek, der giver funktionalitet til at arbejde med miljøvariabler og kommandolinjeargumenter. Det std:: env crate tilbyder en række metoder og typer til at arbejde med miljøer på en platformsuafhængig måde.

Bruger std:: env kasse, kan dine Rust-programmer interagere med miljøet og tilpasse deres adfærd ud fra forskellige faktorer, herunder miljøvariabler, kommandolinjeargumenter og den aktuelle funktion vejviser.

Kør denne kommando for at oprette et nyt Rust-projekt til din CLI-app med Cargo, Rusts pakkehåndteringsværktøj:

last ny crypto_cli

Du lærer, hvordan du bygger en CLI-applikation, der kalder Coinmarketcaps API med Reqwest kasse, der giver funktioner til fremstilling HTTP-anmodninger i Rust.

Åben din Cargo.toml fil og tilføj reqwest og tokio kasser til dit projekts afhængigheder:

[afhængigheder]
tokio = { version = "1.15", funktioner = ["fuld"] }
reqwest = { version = "0.11", funktioner = ["json"] }
serde = { version = "1.0", funktioner = ["aflede"] }
serde_json = "1.0"

Det tokio crate er et asynkront runtime-bibliotek, der interopererer med reqwest til asynkron programmering. Det serde og serde_json kasser hjælper med JSON-serialisering og deserialisering.

I den src mappe for dit Rust-projekt, opret api.rs og cli.rs filer, hvor du implementerer API-kaldet og CLI-funktionaliteterne.

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

Kommandoen skal oprette de ønskede filer i dit projekts arbejdsmappe. Efter at have skrevet funktionaliteterne i deres udpegede filer til adskillelse af bekymringer, kalder du funktionerne i vigtigste funktion i din hoved.rs fil.

Fremstilling af API-anmodninger til CoinMarketCaps API med Reqwest

CoinMarketCap's API giver dig adgang til og integrere cryptocurrency-data i deres applikationer. API'en giver endepunkter for fortegnelser, markedskurser, udvekslingsoplysninger, konverteringsværktøjer, historiske data og metadata.

Når du logger ind, kan du tilmelde dig en CoinMarketCap-konto og hente din API-nøgle på Coinmarketcaps udviklerside. Du kan også henvise til dokumentationen for detaljerede instruktioner og takstgrænser.

For at lave en API-anmodning til /v2/cryptocurrency/quotes/latest endepunkt, der returnerer den seneste markedspris for en eller flere kryptovalutaer, skal du definere strukturer for de data, du vil udtrække fra API'et, og specificer attributterne med Serdes afledte egenskab.

Derefter kan du anmode om en API til slutpunktet og bruge serde_json kasse for at deserialisere JSON-dataene i strukturen for lettere betjening af Rust-datatyper.

Her er struktur definition der henter id, navn, symbol, og citere data fra de angivne kryptovalutaer

#[aflede (Debug, Deserialize, Serialize)]
strukturApiResponse {
 data: data,
}
#[aflede (Debug, Deserialize, Serialize)]
strukturData {
// Tilføj felter, som du skal bruge fra dataobjektet
#[serde (omdøb = "1")]
 crypto_1: Kryptovaluta,
#[serde (omdøb = "2")]
 crypto_2: Kryptovaluta,
#[serde (omdøb = "3")]
 crypto_3: Kryptovaluta,
#[serde (omdøb = "4")]
 crypto_4: Kryptovaluta,
}
#[aflede (Debug, Deserialize, Serialize)]
strukturKryptovaluta {
 id: u32,
 navn: Snor,
 symbol: Snor,
// Tilføj andre felter efter behov
 citat: Citat,
}
#[aflede (Debug, Deserialize, Serialize)]
strukturCitere {
 USD: CitatDetails,
}
#[aflede (Debug, Deserialize, Serialize)]
strukturCitatdetaljer {
 pris: f64,
 volume_24h: f64,
// Tilføj andre felter efter behov
}

API'en returnerer data, der kan være mere end du har brug for, men med serde kasse, kan du angive de nøjagtige data, du har brug for, som vist ovenfor.

Nu kan du anmode om slutpunktet med Reqwest ved at oprette en ny klient, der laver GET-anmodningen med de nødvendige parametre.

brug reqwest:: Kunde;
brug reqwest:: Fejl;
pubasynkronfnkrypto() -> Resultat {
lade klient = Klient:: ny();
lade url = " https://pro-api.coinmarketcap.com/v2/cryptocurrency/quotes/latest";
lade params = [
 ("id", "1,2,3,4"),
 ("konvertere", "USD"), // Konverter markedsværdier til USD
 ];
lade respons = client.get (url)
 .header("X-CMC_PRO_API_KEY", "DIN API NØGLE HER")
 .query(&params)
 .sende().vente?;
 ;
lade resultat: ApiResponse = serde_json:: from_str(&*response.text().vente?;).unwrap();
println!("{:#?}", resultat);
Okay(())
}

Det krypto funktion er en tokio-aktiveret asynkron funktion, der anmoder om endepunktet med klient.få funktion efter at have oprettet en klientforekomst med Kunde:: ny metode.

Det header funktionskald på anmodningsbygger-instansen tager din API-nøgle, forespørgsel funktion tager parametrene ind, og sende funktion sender anmodningen.

Det krypto funktion deserialiserer JSON-svaret med serde_json's fra_str metode, der tager en JSON-streng ind.

Endelig krypto funktion udskriver resultatet af deserialiseringsoperationen til konsollen.

Henter CLI-argumenter i Rust

I din cli.rs fil, importerer du krypto funktion fra api.rs fil og kald funktionen, hvis brugeren arter "crypto" som et argument for at køre projektet med fragtkørsel kommando.

Her er, hvordan du kan bruge std:: env funktion til at hente argumentet fra kommandolinjen:

brug std:: env;
brug kasse:: api:: krypto;
pubasynkronfncli() {
lade argumenter: Vec<Snor> = env:: args().collect();
hvis args.len() > 1 && args[1] == "krypto" {
 krypto().vente.unwrap();
 } andet {
println!("Ugyldig kommando. Anvendelse: cargo run crypto");
 }
}

Det cli funktion henter alle argumenterne fra kommandolinjen med env:: args().collect() fungere. Det hvis ellers sætning kontrollerer, om der er et ekstra argument, "krypto". Hvis den betingede vurderer sand, vil den cli funktionen kalder krypto fungere; ellers cli funktion udskriver en streng til konsollen.

Endelig kan du ringe til cli funktion i vigtigste fungere. Du skal tilføje #[tokio:: main] egenskab siden vigtigste funktioner kan ikke være asynkrone i Rust.

mod api;
mod cli;
brug kasse:: cli:: cli;
#[tokio:: main]
asynkronfnvigtigste() {
 cli().vente;
}

Det vigtigste funktionen kalder cli funktion med vente funktion, der suspenderer udførelsen indtil resultatet af en Fremtid er klar.

Her er resultatet af at køre cargo run krypto kommando:

Du kan bygge sofistikerede webapps i rust

Rust er et alsidigt programmeringssprog med mange use cases og applikationer. Du kan udnytte tredjeparts-webrammer som Actix, Rocket og Warp til at bygge webapplikationer i Rust. Disse rammer giver de fleste af de funktioner, der er nødvendige for at bygge moderne webapps.