Hvordan bygge en grunnleggende CLI-app i Rust

CLI (Command Line Interfaces) er avgjørende i programvareutvikling og systemadministrasjon. CLI-er er lette tekstbaserte programmer som tilbyr en strømlinjeformet måte å samhandle med datamaskiner som er gunstige både for utviklere og avanserte brukere for flere brukstilfeller, inkludert automatisering, skripting og fjernkontroll administrasjon.

Rust blir stadig mer populært for å bygge CLI-apper. Rust gir kraftige funksjoner som finkornet kontroll over minnetildeling og trådsikkerhet, minnesikkerhet, samtidighet og parallellitet som du kan utnytte for å bygge kraftige CLI-apper. Rust kan også skryte av et blomstrende økosystem av biblioteker og rammeverk som er skreddersydd eksplisitt for å bygge CLI-applikasjoner.

Komme i gang Bygge CLI-apper med rust

Det finnes flere tredjepartspakker for å bygge CLI-apper i Rust, inkludert Klapp, StructOpt, og Termion kasser. Disse kassene gir funksjonene du trenger for å utvikle moderne CLI-verktøy.

Rust gir også en std:: env kasse i standardbiblioteket som gir funksjonalitet for arbeid med miljøvariabler og kommandolinjeargumenter. De std:: env crate tilbyr en rekke metoder og typer for å jobbe med miljøer på en plattformuavhengig måte.

Bruker std:: env kasse, kan Rust-programmene dine samhandle med miljøet og tilpasse oppførselen deres basert på ulike faktorer, inkludert miljøvariabler, kommandolinjeargumenter og gjeldende arbeid katalog.

Kjør denne kommandoen for å lage et nytt Rust-prosjekt for CLI-appen din med Cargo, Rusts pakkehåndteringsverktøy:

last ny krypto_cli

Du lærer hvordan du bygger en CLI-applikasjon som kaller Coinmarketcaps API med Reqwest kasse som gir funksjoner for å lage HTTP-forespørsler i Rust.

Åpne din Cargo.toml fil og legg til reqwest og tokio kasser til prosjektets avhengigheter:

[avhengigheter]
tokio = { versjon = "1.15", funksjoner = ["full"] }
reqwest = { versjon = "0.11", funksjoner = ["json"] }
serde = { versjon = "1.0", funksjoner = ["avlede"] }
serde_json = "1.0"

De tokio crate er et asynkront kjøretidsbibliotek som samvirker med reqwest for asynkron programmering. De serde og serde_json kasser hjelper med JSON-serialisering og deserialisering.

I src mappen til Rust-prosjektet ditt, opprett api.rs og kli.rs filer der du implementerer API-kallet og CLI-funksjonene.

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

Kommandoen skal opprette de ønskede filene i prosjektets arbeidskatalog. Etter å ha skrevet funksjonaliteten i de utpekte filene for å separere bekymringer, vil du kalle opp funksjonene i hoved- funksjon i din main.rs fil.

Gjør API-forespørsler til CoinMarketCaps API med Reqwest

CoinMarketCaps API lar deg få tilgang til og integrere kryptovalutadata i applikasjonene deres. API-en gir endepunkter for oppføringer, markedskurser, utvekslingsinformasjon, konverteringsverktøy, historiske data og metadata.

Når du logger på, kan du registrere deg for en CoinMarketCap-konto og hente API-nøkkelen din på Coinmarketcaps utviklerside. Du kan også se dokumentasjonen for detaljerte instruksjoner og takstgrenser.

For å sende en API-forespørsel til /v2/cryptocurrency/quotes/latest endepunkt som returnerer det siste markedstilbudet for en eller flere kryptovalutaer, må du definere strukturer for dataene du vil trekke ut fra API og spesifisere attributtene med Serdes avledede egenskap.

Deretter kan du be om en API til endepunktet og bruke serde_json kasse for å deserialisere JSON-dataene inn i strukturen for enklere operasjoner på Rust-datatyper.

Her er strukturdefinisjon som henter id, Navn, symbol, og sitat data fra de angitte kryptovalutaene

#[avlede (feilsøke, deserialisere, serialisere)]
strukturApiResponse {
 data: data,
}
#[avlede (feilsøke, deserialisere, serialisere)]
strukturData {
// Legg til felt du trenger fra dataobjektet
#[serde (gi nytt navn = "1")]
 krypto_1: Kryptovaluta,
#[serde (gi nytt navn = "2")]
 krypto_2: Kryptovaluta,
#[serde (gi nytt navn = "3")]
 krypto_3: kryptovaluta,
#[serde (gi nytt navn = "4")]
 krypto_4: Kryptovaluta,
}
#[avlede (feilsøke, deserialisere, serialisere)]
strukturKryptovaluta {
 id: u32,
 Navn: String,
 symbol: String,
// Legg til andre felt etter behov
 sitat: sitat,
}
#[avlede (feilsøke, deserialisere, serialisere)]
strukturSitat {
 USD: Sitatdetaljer,
}
#[avlede (feilsøke, deserialisere, serialisere)]
strukturSitatdetaljer {
 pris: f64,
 volume_24h: f64,
// Legg til andre felt etter behov
}

API-en returnerer data som kan være mer enn du trenger, men med serde kasse, kan du spesifisere de nøyaktige dataene du trenger, som vist ovenfor.

Nå kan du be om endepunktet med Reqwest ved å opprette en ny klient som lager GET-forespørselen med de nødvendige parameterne.

bruk reqwest:: Klient;
bruk reqwest:: Feil;
pubasynkronfnkrypto() -> Resultat {
la klient = Klient:: ny();
la url = " https://pro-api.coinmarketcap.com/v2/cryptocurrency/quotes/latest";
la params = [
 ("id", "1,2,3,4"),
 ("konvertere", "USD"), // Konverter markedsverdier til USD
 ];
la respons = client.get (url)
 .Overskrift("X-CMC_PRO_API_KEY", "DIN API NØKKEL HER")
 .query(&params)
 .sende().avvente?;
 ;
la resultat: ApiResponse = serde_json:: from_str(&*response.text().avvente?;).unwrap();
println!("{:#?}", resultat);
Ok(())
}

De krypto funksjon er en tokio-aktivert asynkron funksjon som ber om endepunktet med klient.få funksjon etter å ha opprettet en klientforekomst med Klient:: ny metode.

De Overskrift funksjonskall på forespørselsbyggerforekomsten tar inn API-nøkkelen din, spørsmål funksjonen tar inn parameterne, og sende funksjonen sender forespørselen.

De krypto funksjon deserialiserer JSON-svaret med serde_jsons fra_str metode som tar inn en JSON-streng.

Til slutt, den krypto funksjonen skriver ut resultatet av deserialiseringsoperasjonen til konsollen.

Henter CLI-argumenter i Rust

I din kli.rs fil, importerer du krypto funksjon fra api.rs fil og kall opp funksjonen hvis brukeren arter "crypto" som et argument for å kjøre prosjektet med lastekjøring kommando.

Her er hvordan du kan bruke std:: env funksjon for å hente argumentet fra kommandolinjen:

bruk std:: env;
bruk kasse:: api:: krypto;
pubasynkronfncli() {
la args: Vec<String> = env:: args().collect();
hvis args.len() > 1 && args[1] == "krypto" {
 krypto().avvente.unwrap();
 } ellers {
println!("Ugyldig kommando. Bruk: cargo run crypto");
 }
}

De cli funksjonen henter alle argumentene fra kommandolinjen med env:: args().collect() funksjon. De hvis-annet setningen sjekker om det er et ekstra argument, "krypto". Hvis den betingede evaluerer sann, vil den cli funksjonen kaller krypto funksjon; ellers cli funksjonen skriver ut en streng til konsollen.

Til slutt kan du ringe cli funksjon i hoved- funksjon. Du må legge til #[tokio:: main] attributt siden hoved- funksjoner kan ikke være asynkrone i Rust.

mod api;
mod cli;
bruk kasse:: cli:: cli;
#[tokio:: main]
asynkronfnhoved-() {
 cli().avvente;
}

De hoved- funksjonen kaller cli funksjon med avvente funksjon som suspenderer utførelse til resultatet av en Framtid er klar.

Her er resultatet av å kjøre cargo run krypto kommando:

Du kan bygge sofistikerte webapper i rust

Rust er et allsidig programmeringsspråk med mange bruksområder og applikasjoner. Du kan utnytte tredjeparts nettrammeverk som Actix, Rocket og Warp for å bygge nettapplikasjoner i Rust. Disse rammene gir de fleste funksjonene som trengs for å bygge moderne nettapper.