Rust Files and IO

Dieses Kapitel stellt die Sprache Rust vor/O Operation.

Empfangen von Befehlszeilenparametern

Ein Befehlszeilenprogramm ist die grundlegendste Form eines Computersprogramms, fast alle Betriebssysteme unterstützen Befehlszeilenprogramme und basieren auf dem Befehlszeilenmechanismus auf die Ausführung visueller Programme.

Ein Befehlszeilenprogramm muss in der Lage sein, Parameter aus der Befehlszeilenumgebung zu empfangen, diese Parameter werden oft nach einem Befehlszeilenbefehl durch Leerzeichen getrennt.

In vielen Sprachen (wie Java und C/C++Die Umgebungsparameter werden als Parameter des Hauptprogramms (oft ein String-Array) an das Programm weitergegeben, aber in Rust ist die Hauptfunktion eine parameterlose Funktion, die Umgebungsparameter müssen durch den Entwickler über den Modul std::env abgerufen werden, der Prozess ist sehr einfach:

fn main() {
　　　　let args = std::env::args();
　　　　println!("{:?}", args);
}

Führe das Programm jetzt direkt aus:

Args { inner: ["D:\\rust\\greeting\\target\\debug\\greeting.exe"] }

Vielleicht bekommst du ein längeres Ergebnis als dieses, das ist normal, in diesem Ergebnis gibt es eine inner Array im Args-Strukturtyp, das nur einzigartige Strings enthält und den Ort des derzeit laufenden Programms darstellt.

Diese Datenstruktur ist schwer zu verstehen, aber keine Sorge, wir können sie einfach durchsuchen:

fn main() {
　　　　let args = std::env::args();
　　　　for arg in args {
　　　　　　　　println!("{}", arg);
　　　　}
}

Laufende Ergebnisse:

D:\rust\greeting\target\debug\greeting.exe

Allgemeine Parameter werden einfach durchsucht, oder?

Jetzt öffnen wir das lange nicht mehr genutzte Datei launch.json, finden "args": [], hier können Sie die Laufzeitparameter einstellen, wir schreiben es "args": ["first", "second"]", dann speichern und das soeben ausgeführte Programm erneut ausführen, das Ergebnis des Laufens:

D:\rust\greeting\target\debug\greeting.exe
first
second

Als echter Befehlszeilenprogramm haben wir es nie wirklich verwendet, als Sprachlehrbuch wird hier nicht beschrieben, wie man Rust-Programme über die Befehlszeile ausführt. Aber wenn du ein geschulter Entwickler bist, solltest du den Ort der ausführbaren Datei finden können, du kannst versuchen, in das Verzeichnis einzutreten und den Befehlszeilenbefehl zu verwenden, um das Programm zu testen, ob es Umgebungsparameter der Befehlszeile akzeptiert.

Kommandozeilen-Eingabe

Frühere Kapitel haben detailliert die Verwendung von Kommandozeilen-Ausgaben beschrieben, dies ist auf die Bedürfnisse des Sprachlernens zurückzuführen, da ein Programm ohne Ausgabe nicht getestet werden kann. Allerdings ist die Information, die von der Kommandozeile abgerufen wird, für ein Kommandozeilenprogramm immer noch sehr wichtig.

In Rust bietet das Modul std::io Funktionen für die Standard-Eingabe (die als Kommandozeileingabe betrachtet werden kann):

use std::io::stdin;
fn main() {
let mut str_buf = String::new();
　　　　stdin().read_line(&mut str_buf)
　　　　　　　　.expect("Failed to read line.");
　　　　println!("Ihre Eingabezeile ist 
{}", str_buf);
}

Es ist sehr mühsam, VSCode-Umgebungen so zu konfigurieren, dass sie Eingaben von der Kommandozeile unterstützen, da dies Probleme zwischen Plattformen und Unfähigkeit zur Fehlersuche mit sich bringt, daher führen wir das Programm direkt im VSCode-Terminal aus. Führen Sie im Befehlszeilenfenster aus:

D:\rust\greeting> cd ./target/debug
D:\rust\greeting\target\debug> ./greeting.exe
w3codebox
Ihre Eingabezeile ist　
w3codebox

std::io::Stdio enthält die Lesemethode read_line, die eine Zeile als String in den Puffer liest und den Wert der Result-Abstrakten Klasse zurückgibt, die zur Übermittlung von Fehlern während des Lesens verwendet wird, daher werden die Funktionen expect oder unwrap oft verwendet, um Fehler zu behandeln.

Note：Der Rust-Standardbibliothek wurde noch keine direkte Methode zum Lesen von Zahlen oder formatierten Daten aus der Kommandozeile bereitgestellt, daher können wir eine Zeile als String lesen und die Daten mit den String-Erkennungsfunktionen verarbeiten.

DateileSEN

Wir erstellen im Verzeichnis D:\ unter dem Computer eine Datei namens text.txt, deren Inhalt wie folgt ist:

Dies ist eine Textdatei.

Dies ist ein Programm, das den Inhalt einer Textdatei in einen String einliest:

use std::fs;
fn main() {
　　　　let text = fs::read_to_string("D:\\text.txt").unwrap();
　　　　println!("{}", text);
}

Laufende Ergebnisse:

Dies ist eine Textdatei.

Das Lesen einer gesamten Datei, die vom Speicher des Computers aufgenommen werden kann, ist in Rust äußerst einfach, die Methode read_to_string im Modul std::fs kann den Lesevorgang von Textdateien leicht bewerkstelligen.

Wenn die zu lesende Datei ein Binärfahr ist, können wir die Funktion std::fs::read verwenden, um u zu lesen8 Typensammlung:

use std::fs;
fn main() {
　　　　let content = fs::read("D:\\text.txt").unwrap();
　　　　println!("{:?}", content);
}

Laufende Ergebnisse:

[84,　104,　105,　115,　32,　105,　115,　32,　97,　32,　116,　101,　120,　116,　32,　102,　105,　108,　101,　46]

Diese beiden Arten sind Einmallesen und sind sehr gut geeignet für die Entwicklung von Web-Anwendungen. Ancak für einige untere Programme bleibt der traditionelle Stream-Lese-Modus unverzichtbar, da in vielen Fällen die Größe der Datei möglicherweise weit über die Kapazität des Arbeitsspeichers hinausgeht.

Rust-Dateistream-Leseart:

use std::io::prelude::*;
use std::fs;
fn main() {
　　　　let mut buffer = [0u8;　5];
　　　　let mut file = fs::File::open("D:\\text.txt").unwrap();
　　　　file.read(&mut buffer).unwrap();
　　　　println!("{:?}", buffer);
　　　　file.read(&mut buffer).unwrap();
　　　　println!("{:?}", buffer);
}

Laufende Ergebnisse:

[84,　104,　105,　115,　32]　
[105,　115,　32,　97,　32]

Die Klasse File im Modul std::fs beschreibt Dateien und kann verwendet werden, um Dateien zu öffnen. Nachdem die Datei geöffnet wurde, können wir mit dem read-Method der Datei einige Bytes der Datei in den Puffer lesen (ein Puffer ist ein u8 Array), die gelesenen Bytes entsprechen der Länge des Puffers.

Hinweis: VSCode verfügt derzeit nicht über die Funktion, Standardbibliotheksreferenzen automatisch hinzuzufügen, daher könnten Fehler wie "Funktion oder Methode nicht vorhanden" möglicherweise auf ein Problem mit den Standardbibliotheksreferenzen zurückzuführen sein. Wir können die Kommentardokumentation der Standardbibliothek (wenn Sie mit der Maus darüber fahren, erscheint sie) überprüfen, um die Standardbibliothek manuell hinzuzufügen.

Die Methode open von std::fs::File öffnet eine Datei im Modus "Nur Lesen" und hat keine zugehörige close-Methode, da der Rust-Compiler Dateien automatisch schließen kann, wenn sie nicht mehr verwendet werden.

Datei-Schreiben

Datei-Schreiben wird in Einmal-Schreiben und Stream-Schreiben unterteilt. Stream-Schreiben erfordert das Öffnen der Datei, wobei es zwei Arten gibt: "Neu erstellen" (create) und "Anhängen" (append).

Einmaliges Schreiben:

use std::fs;
fn main() {
　　　　fs::write("D:\\text.txt", "FROM　RUST　PROGRAM")
　　　　　　　　.unwrap();
}

Das ist so einfach und bequem wie beim Einmallesen. Nach der Ausführung des Programms wird der Inhalt der Datei D:\text.txt in FROM RUST PROGRAM geändert. Also verwenden Sie das Einmal schreiben bitte vorsichtig! Da es den Dateiinhalt direkt löscht (unabhängig von der Größe der Datei). Wenn die Datei nicht existiert, wird sie erstellt.

Wenn Sie Dateiinhalte auf Stream-Weise schreiben möchten, können Sie die Methode create von std::fs::File verwenden:

use std::io::prelude::*;
use std::fs::File;
fn main() {
　　　　let mut file = File::create("D:\\text.txt").unwrap();
　　　　file.write(b"FROM RUST PROGRAM").unwrap();
}

This program is equivalent to the previous program.

NoteThe opened file must be stored in a mutable variable to use the File's methods!

There is no append static method in the File class, but we can use OpenOptions to implement opening files with specific methods:

use std::io::prelude::*;
use std::fs::OpenOptions;
fn main()　-> std::io::Result<()> {
　　　　
　　　　let mut file = OpenOptions::new()
　　　　　　　　　　　　.append(true).open("D:\\text.txt")?;
　　　　file.write(b"　APPEND　WORD")?;
　　　　Ok(())
}

After running, the content of the D:\text.txt file will become:

FROM RUST PROGRAM APPEND WORD

OpenOptions is a flexible method to open files, which can set open permissions, including read and write permissions, except for append permissions. If we want to open a file with read and write permissions, we can write it like this:

use std::io::prelude::*;
use std::fs::OpenOptions;
fn main()　-> std::io::Result<()> {
　　　　
　　　　let mut file = OpenOptions::new()
　　　　　　　　　　　　.read(true).write(true).open("D:\\text.txt")?;
　　　　file.write(b"COVER")?;
　　　　Ok(())
}

After running, the content of the D:\text.txt file will become:

COVERRUST PROGRAM APPEND WORD