Rust kommandolinje argumenter

Kommandolinjeargumenter refererer til et sett med verdier eller spesifikasjoner som sendes til navnet på et terminalprogram. Disse argumentene kan derfor endre oppførselen til programmet som definert i kildekoden.

For eksempel kan du sende katalogen du ønsker å liste til LS -kommandoen. Derfor er banen til katalogen kjent som argumentet for LS -kommandoen.

Denne artikkelen vil gå over det grunnleggende om å akseptere og analysere kommandolinjeargumenter i rustprogrammeringsspråket ved å bruke Env -modulen fra standardbiblioteket.

Oppsett og import

Det første trinnet er å opprette en katalog for å lagre kildekoden vår. For enkelhets skyld, la oss generere en rustpakke som bruker last som:

$ last nye rust_argumenter

Gi nytt navn til prosjektet ditt til et hvilket som helst navn du synes passer.

Naviger deretter inn i kildekatalogen og åpne hoved.RS -fil med din favoritt tekstredigerer.

$ cd rust_argumenter/src && vim main.Rs

Det andre trinnet er å importere de nødvendige modulene. Vi vil bruke Env-modulen fra standardbiblioteket for å analysere kommandolinjeargumenter for denne artikkelen.

Env -modulen gir en funksjon for å jobbe med miljøvariabler, argumenter osv. For å bruke den, importer den ved hjelp av som:

Bruk std :: env;

Argumentvektor

Inne i hovedfunksjonen må vi lage en vektor av strenger som vil holde argumentene vi vil gi til programmet.

Vi kan gjøre dette ved å legge til følgende linje:

La Args: VEC = env :: args ().samle inn();

Koden over bruker samle metoden for å iterere over argumentet som er gitt til argumentene og legge dem til vektoren. Vektoren er av typestrenger som merket av VEC i vårt tilfelle. Dette er fordi rust ikke kan utlede typen vektorsamling.

Skriv ut argumenter

Nå som vi kan godta kommandoargumenter og lagre dem i en vektor, la oss prøve å skrive dem ut. Vi kan gjøre dette med ITER -funksjonen, som vist nedenfor:

Bruk std :: env;
fn main ()
La Args: VEC = env :: args ().samle inn();
For Arg i args.iter ()
Println!("", arg);

ITER -funksjonen vil iterere over hvert argument overført til programmet og skrive ut det. Hvis vi kjører koden over, bør vi se en utdata som:

Programmet returnerer navnet på den kjørbare. Rust vil behandle navnet på den kjørbare som det første argumentet. Derfor er argumentet ved indeks 0 i argumentvektoren veien til navnet på programmet.

Dette er et vanlig trekk i andre programmeringsspråk, inkludert C, Python, Go, etc.

Hvis vi gir andre argumenter etter navnet på programmet, vil Rust legge dem til indeks 1, 2, 3 ... til argumentvektoren.

For eksempel:

lasteløp argument1 argument2 argument3 ... argumentn

Merk at eksemplet over passerer 5 argumenter til programmet. Resultatet er som vist:

Target \ Debug \ rust_cmd_args.EXE
Argument1
Argument2
Argument3
..
Argumentn

Som du ser, skriver programmet tilbake alle argumentene som er bestått.

Få tilgang til og lagre argumenter

Til nå har vi bare skrevet ut argumentene fra programmet. Selv om det illustrerer hvordan argumentvektorer fungerer, gjør det ikke så mye.

Vi kan få tilgang til og lagre hvert argument til en variabel for å utvide programmet vårt.

For å få tilgang til et argument, kan vi bruke indeksen som:

Bruk std :: env;
fn main ()
La Args: VEC = env :: args ().samle inn();
Println!("", args [1]);

I eksemplet over får vi tilgang til det første argumentet ved hjelp av indeks 1. Resultatet er som vist:

Cargo Run Hei!

Vi kan lagre argumentet i en variabel som:

Bruk std :: env;
fn main ()
La Args: VEC = env :: args ().samle inn();
La hilsen = & args [1];
Hvis hilsen == "Hei"
Println!("Hei tilbake!");
annet
Println!("Vi godtar bare hilsener!")

I programmet over aksepterer vi å lagre det første argumentet og lagre det i en variabel. Vi bruker deretter verdien i en IF… ellers blokkering for å utføre en handling.

Vi kan kjøre koden over som:

$ Cargo Run Hei

Programmet skal returnere “Hei tilbake!" som:

Hvis vi passerer et annet argument som ikke tilsvarer "hei", utførte vi den andre blokken som:

$ Cargo Run Bye

Konklusjon

Fantastisk! Vi har et program som kan akseptere, analysere, lagre og argumenter med det. Fortsett å øve for å lære mer.