Come leggere un file usando il linguaggio ruggine

La capacità di leggere i file è fondamentale per qualsiasi sviluppatore. Ci consente di caricare informazioni da fonti esterne e manipolarle come ci vediamo opportuno.

In questo articolo, discuteremo di vari trucchi e metodi per leggere i file nel linguaggio di programmazione Rust.

Configurazione del progetto

Il set iniziale è quello di creare una struttura del progetto. Possiamo farlo usando il comando cargo come:

$ cargo nuovo read_file

Il comando precedente inizializzerà un nuovo progetto con il nome specificato. Nella directory di root, aggiungi un file di testo che conterrà i dati di esempio che leggeremo con ruggine.

Questo tutorial utilizzerà un semplice file di testo contenente le informazioni ARP da una macchina Windows.

Le informazioni sul campione sono come mostrate:

Interfaccia: 192.168.0.104 --- 0xc
Indirizzo Internet Tipo di indirizzo fisico
192.168.0.1 D4-B1-06-99-3B-63 Dynamic
192.168.0.255 FF-FF-FF-FF-FF FF statico
224.0.0.22 01-00-5E-00-00-16 statico
224.0.0.251 01-00-5E-00-00-FB statico
224.0.0.252 01-00-5E-00-00-FC statico
239.255.255.250 01-00-5E-7F-FF-FA
255.255.255.255 FF-FF-FF-FF-FF FF statico
Interfaccia: 192.168.192.1 --- 0x16
Indirizzo Internet Tipo di indirizzo fisico
192.168.194.72 00-15-5d-A5-46-20 dinamico
192.168.195.230 00-15-5d-A5-40-17 dinamico
192.168.202.115 00-15-5d-A5-4A-C1 Dynamic
192.168.205.217 00-15-5d-A5-47-CD dinamico
192.168.207.255 FF-FF-FF-FF-FF FF statico
224.0.0.22 01-00-5E-00-00-16 statico
224.0.0.251 01-00-5E-00-00-FB statico
239.192.152.143 01-00-5E-40-98-8F statico
239.255.255.250 01-00-5E-7F-FF-FA

Con l'impostazione del progetto e il file di esempio pronto, possiamo leggere il contenuto del file.

Leggi il file come stringa

Il primo e più semplice metodo per leggere un file in ruggine è caricarlo come un'intera stringa. Possiamo farlo usando il metodo std :: fs :: read_to_string.

Il seguente codice mostra come è possibile leggere un file come stringa in ruggine:

Usa std :: fs :: file;
Usa std :: io :: prelude ::*;
fn main ()
let mut file = file :: open ("ARP.TXT")
.Aspettatevi ("file non trovato");
let mut data = string :: new ();
file.read_to_string (& mut data)
.Aspettatevi ("Errore durante la lettura del file");
println!("", dati);

Il codice precedente importa la struttura del file e il modulo preludio. Nella funzione principale, creiamo una variabile mutabile chiamata file e cariciamo aprire l'ARP.file txt per la lettura.

Successivamente, leggiamo il contenuto del file utilizzando read_to_string e passiamo un riferimento mutabile alla variabile dati. Quindi, possiamo stampare il contenuto del file utilizzando println! macro.

Possiamo eseguire il codice come:

$ cargo run

Leggi la riga del file per riga

Possiamo anche leggere una riga del file per riga usando le righe iterator. L'iteratore opererà sul bufreader dall'oggetto file. Di seguito è riportato un codice di esempio:

Usa std :: fs :: file;
Usa std :: io :: bufreader;
Usa std :: io :: prelude ::*;
fn main ()-> std :: io :: result<()>
let file = file :: open ("ARP.TXT")
.Aspettatevi ("File non trovato!");
let buf_reader = bufreader :: new (file);
per la linea in buf_reader.linee()
println!("", linea?);

OK(())

Leggi il file come vettore

Possiamo anche leggere un file come vettore come mostrato nel codice di esempio fornito di seguito:

fn read_file () -> std :: io ::>
let mut file = file :: open ("ARP.TXT")?;
let mut buf = vec :: new ();
file.read_to_end (& mut dati);
restituire OK (dati);

Il codice precedente utilizza il metodo Vec :: Nuovo per creare un nuovo vettore vuoto. Quindi, utilizziamo Read_to_end per leggere i byte fino alla fine del file e inserirli nel buffer.

Conclusione

In questo articolo, abbiamo trattato le basi dell'operazione di file utilizzando il linguaggio di programmazione Rust. Inoltre, abbiamo illustrato vari metodi e tecniche utilizzati per leggere i file. Speriamo che tu abbia trovato questo articolo utile. Controlla gli altri articoli di suggerimento Linux per ulteriori suggerimenti e informazioni.