Hvordan lese en fil ved hjelp av rustspråket

Muligheten til å lese filer er kritisk viktig for enhver utvikler. Det lar oss laste inn informasjon fra eksterne kilder og manipulere den når vi ser passende.

I denne artikkelen vil vi diskutere forskjellige triks og metoder for å lese filer på Rust -programmeringsspråket.

Prosjektoppsett

Det første settet er å lage en prosjektstruktur. Vi kan gjøre dette ved å bruke lastekommandoen som:

$ last ny read_file

Den forrige kommandoen vil initialisere et nytt prosjekt med det spesifiserte navnet. I rotkatalogen, legg til en tekstfil som vil inneholde eksempeldataene vi vil lese med rust.

Denne opplæringen vil bruke en enkel tekstfil som inneholder ARP -informasjon fra en Windows -maskin.

Eksempelinformasjon er som vist:

Grensesnitt: 192.168.0.104 --- 0xc
Internett -adresse Fysisk adressetype
192.168.0.1 D4-B1-06-99-3B-63 Dynamic
192.168.0.255 FF-FF-FF-FF-FF-FF-statisk
224.0.0.22 01-00-5E-00-00-16 Statisk
224.0.0.251 01-00-5E-00-00-FB Statisk
224.0.0.252 01-00-5E-00-00-FC Statisk
239.255.255.250 01-00-5E-7F-FF-FA Static
255.255.255.255 FF-FF-FF-FF-FF-FF-statisk
Grensesnitt: 192.168.192.1 --- 0x16
Internett -adresse Fysisk adressetype
192.168.194.72 00-15-5D-A5-46-20 Dynamic
192.168.195.230 00-15-5D-A5-40-17 Dynamic
192.168.202.115 00-15-5D-A5-4A-C1 Dynamic
192.168.205.217 00-15-5D-A5-47-CD Dynamic
192.168.207.255 FF-FF-FF-FF-FF-FF-statisk
224.0.0.22 01-00-5E-00-00-16 Statisk
224.0.0.251 01-00-5E-00-00-FB Statisk
239.192.152.143 01-00-5E-40-98-8F Statisk
239.255.255.250 01-00-5E-7F-FF-FA Static

Med prosjektoppsettet og eksemplerfilen klar, kan vi lese filens innhold.

Les fil som en streng

Den første og enkleste metoden for å lese en fil i rust er å laste den som en hel streng. Vi kan oppnå dette ved hjelp av std :: fs :: read_to_string -metoden.

Følgende kode viser hvordan du kan lese en fil som en streng i rust:

Bruk std :: fs :: fil;
Bruk std :: io :: Prelude ::*;
fn main ()
La Mut File = File :: Open ("ARP.tekst")
.Forvent ("Fil ikke funnet");
La MUT -data = String :: new ();
fil.read_to_string (& mut data)
.Forvent ("Feil mens du leser filen");
Println!("", data);

Den forrige koden importerer filstrukturen og Prelude -modulen. I hovedfunksjonen oppretter vi en mutbar variabel kalt fil og laster opp ARP.txt -fil for lesing.

Deretter leste vi filens innhold ved hjelp av read_to_string og passerer en mutbar referanse til datavariabelen. Deretter kan vi skrive ut innholdet i filen ved hjelp av println! makro.

Vi kan kjøre koden som:

$ Cargo Run

Les fillinje for linje

Vi kan også lese en fillinje for linje ved hjelp av linjene iterator. Iteratoren vil operere på BufReader fra filobjektet. Et eksempelkode er gitt nedenfor:

Bruk std :: fs :: fil;
Bruk std :: io :: bufreader;
Bruk std :: io :: Prelude ::*;
fn main ()-> std :: io :: resultat<()>
La fil = fil :: Åpne ("ARP.tekst")
.Forvent ("Fil ikke funnet!");
la buf_reader = bufReader :: new (fil);
for linje i buf_reader.linjer ()
Println!("", linje?);

OK (())

Les fil som vektor

Vi kan også lese en fil som en vektor som vist i eksempelkoden nedenfor:

fn read_file () -> std :: io :: Resultat>
La Mut File = File :: Open ("ARP.tekst")?;
La mut buf = vec :: new ();
fil.read_to_end (& mut data);
return OK (data);

Den forrige koden bruker VEC :: Ny metode for å lage en ny tom vektor. Deretter bruker vi read_to_end for å lese byte til slutten av filen og plassere dem i bufferen.

Konklusjon

I denne artikkelen dekket vi det grunnleggende om filoperasjon ved hjelp av Rust -programmeringsspråket. I tillegg illustrerte vi forskjellige metoder og teknikker som ble brukt til å lese filer. Vi håper du fant denne artikkelen nyttig. Sjekk de andre Linux -hint -artiklene for flere tips og informasjon.