Hvordan lese filer på rustspråk

Evnen og funksjonaliteten til å lese filer er så enkel som å klikke på en knapp i et grafisk grensesnitt. Selv om implementering av fillesoperasjoner i et program ikke er så grei som et knappeklikk, er det relativt enkelt.

Hei rustaceans! Denne guiden vil lære deg å lese filer ved hjelp av Rust -programmeringsspråket.

Eksempelfil

Selv om du kan lese en fil som er lagret på et hvilket som helst sted i filsystemet ditt, vil vi holde vår prøvefil i den gjeldende arbeidskatalogen i den gjeldende arbeidskatalogen.

Start med å generere et nytt prosjekt som:

$ last ny rust_read_file

Deretter navigerer du inn i katalogen som:

$ cd rust_read_file/src

Inne i SRC -katalogen, oppretter du en prøveprøvefil.

$ berøringsprøve.tekst
ekko "Hei, jeg er inne i prøven.txt -fil "> prøve.tekst

De tidligere kommandoene vil opprette en ny tekstfil og skrive den til prøven.txt -fil.

Les fil som en streng

Den enkleste metoden for å lese en fil er å lese den som en streng. Denne metoden laster inn filens innhold i minnet og lar deg manipulere filen.

Vi kan gjøre dette ved hjelp av read_to_string -metoden fra Read -modulen til IO -pakken. Et eksempel er gitt nedenfor:

Bruk std :: fs :: fil;
Bruk std :: io :: Les;
fn main ()
La MUT -fil = fil :: Åpne ("Eksempel.tekst")
.Forvent ("Feilåpningsfil");
La MUT -data = String :: new ();
fil.read_to_string (& mut data)
.Forvent ("Feillesingsfil");
Println!("", data);

I forrige kode startet vi med å importere de nødvendige modulene for håndtering av filer. Disse inkluderer fs :: filen og io :: Les fra standardbiblioteket.

Den første uttalelsen i hovedfunksjonen skaper et mutabelt håndtak til filen vi ønsker å åpne. Vi gjør dette ved å bruke filen :: Open -metoden og gi navnet på filen som argumentasjonen.

Den andre uttalelsen har en mutbar variabel som inneholder dataene til filen. Vi oppretter dette som en tom streng som vi deretter kan laste inn dataene til filen.

Til slutt kaller vi LES_TO_STRING -metoden for å lese filen og gi en mutbar referanse til datavariabelen. Dette vil skrive innholdet i filen til den tomme strengen.

Deretter kan vi skrive ut innholdet i filen ved hjelp av println! metode.

Å kjøre forrige kode skal returnere innholdet i prøven.tekst

$ Cargo Run

Hei, jeg er inne i prøven.tekst

Les fillinje for linje

Vi kan lese en fillinje for linje ved hjelp av linjene () -metoden. Tenk på eksempelkoden vist nedenfor:

Bruk std :: fs :: fil;
Bruk std :: io :: bufreader;
Bruk std :: io :: Prelude ::*;
fn main () -> std :: io :: resultat<()>
La fil = fil :: Åpne ("Eksempel.tekst")
.Forvent ("Feilåpningsfil");
La Mut Reader = BufReader :: new (fil);
for linje i leseren.linjer ()
Println!("", linje?);

OK (());

Den forrige koden bruker filen :: Open () -metoden for å lese prøven.tekst. Følgende linje oppretter en mutbar leser ved hjelp av bufreader :: nytt og passerer filobjektet. Deretter itererer vi linjene i filen og skriver ut innholdet.

Konklusjon

I denne artikkelen dekket vi to hovedmetoder for å lese filer på Rust -programmeringsspråket. Selv om koden som er implementert i denne artikkelen fungerer bra for små filer, kan den raskt bli kompleks med omfattende filer. Tenk derfor på å organisere leseoperasjonene i frittstående funksjoner. Dette kan bidra til å redusere belastningen på hovedfunksjonen. Vi håper du fant denne artikkelen nyttig. Sjekk de andre Linux -hint -artiklene for flere tips og informasjon.