Come leggere i file in lingua ruggine

L'abilità e la funzionalità di leggere i file sono semplici come fare clic su un pulsante in un'interfaccia grafica. Sebbene l'implementazione delle operazioni di lettura dei file in un programma non sia semplice come un clic del pulsante, è relativamente facile.

Ciao Rustacei! Questa guida ti insegnerà a leggere i file utilizzando il linguaggio di programmazione Rust.

File di esempio

Sebbene sia possibile leggere un file archiviato in qualsiasi posizione del tuo filesystem, per illustrazione, conserveremo il nostro file di esempio nella directory di lavoro corrente.

Inizia generando un nuovo progetto come:

$ cargo nuovo rust_read_file

Successivamente, naviga nella directory come:

$ CD RUST_READ_FILE/SRC

All'interno della directory SRC, crea un file di test di esempio.

$ touch campione.TXT
echo "Ciao, sono all'interno del campione.file txt "> campione.TXT

I comandi precedenti creeranno un nuovo file di testo e lo scriveranno al campione.file txt.

Leggi il file come stringa

Il metodo più semplice per leggere un file è leggerlo come una stringa. Questo metodo carica il contenuto del file in memoria e consente di manipolare il file.

Possiamo farlo usando il metodo read_to_string dal modulo di lettura del pacchetto IO. Un esempio è fornito di seguito:

Usa std :: fs :: file;
Usa std :: io :: leggi;
fn main ()
let mut file = file :: open ("campione.TXT")
.Aspettate ("File di apertura degli errori");
let mut data = string :: new ();
file.read_to_string (& mut data)
.Aspettatevi ("Error Reading File");
println!("", dati);

Nel codice precedente, abbiamo avviato importando i moduli richiesti per la gestione dei file. Questi includono FS :: File e Io :: Leggi dalla libreria standard.

La prima istruzione nella funzione principale crea un manico mutabile al file che desideriamo aprire. Lo facciamo utilizzando il metodo del file :: Open e passare il nome del file come argomento.

La seconda istruzione contiene una variabile mutabile contenente i dati del file. Creiamo questo come una stringa vuota a cui possiamo quindi caricare i dati del file.

Infine, chiamiamo il metodo read_to_string per leggere il file e passiamo un riferimento mutabile alla variabile dati. Questo scriverà il contenuto del file nella stringa vuota.

Quindi, possiamo stampare il contenuto del file utilizzando println! metodo.

L'esecuzione del codice precedente dovrebbe restituire il contenuto nel campione.TXT

$ cargo run

Ciao, sono all'interno del campione.TXT

Leggi la riga del file per riga

Possiamo leggere una riga di file per riga usando il metodo righe (). Considera il codice di esempio mostrato di seguito:

Usa std :: fs :: file;
Usa std :: io :: bufreader;
Usa std :: io :: prelude ::*;
fn main () -> std :: io :: result<()>
let file = file :: open ("campione.TXT")
.Aspettate ("File di apertura degli errori");
let mut reader = bufreader :: new (file);
per riga in lettore.linee()
println!("", linea?);

OK(());

Il codice precedente utilizza il metodo File :: Open () per leggere il campione.TXT. La riga seguente crea un lettore mutabile usando bufreader :: new e passa l'oggetto file. Quindi, iteliamo le righe nel file e stampiamo il contenuto.

Conclusione

In questo articolo, abbiamo coperto due principali metodi di lettura dei file nel linguaggio di programmazione Rust. Sebbene il codice implementato in questo articolo funzioni perfettamente per piccoli file, può essere rapidamente complesso con file estesi. Quindi, prendi in considerazione l'organizzazione delle operazioni di lettura in funzioni autonome. Ciò può aiutare a ridurre il carico sulla funzione principale. Speriamo che tu abbia trovato questo articolo utile. Controlla gli altri articoli di suggerimento Linux per ulteriori suggerimenti e informazioni.