Rust-Dateien und E/A
Dieses Kapitel führt in die E/A-Operationen der Sprache Rust ein.
Empfangen von Kommandozeilenargumenten
Kommandozeilenprogramme sind die grundlegendste Form von Computerprogrammen. Nahezu alle Betriebssysteme unterstützen Kommandozeilenprogramme und stützen die Ausführung visueller Programme auf den Kommandozeilenmechanismus.
Ein Kommandozeilenprogramm muss in der Lage sein, Argumente aus der Kommandozeilenumgebung zu empfangen. Diese Argumente erscheinen normalerweise nach einem Kommandozeilenbefehl und werden durch Leerzeichen getrennt.
In vielen Sprachen (wie Java und C/C++) werden Umgebungsargumente als Parameter der main-Funktion (oft ein String-Array) an das Programm übergeben. In Rust ist die main-Funktion jedoch eine parameterlose Funktion, und Umgebungsargumente müssen vom Entwickler über das Modul std::env abgerufen werden. Der Vorgang ist sehr einfach:
Beispiel
let args = std::env::args();
println!("{:?}", args);
}
Führen Sie das Programm nun direkt aus:
Args { inner: ["D:\\rust\\greeting\\target\\debug\\greeting.exe"] }Vielleicht ist das Ergebnis, das Sie erhalten, viel länger als dieses, was normal ist. In diesem Ergebnis enthält die Args-Struktur ein inneres Array, das nur eine einzige Zeichenkette enthält, die den Speicherort des aktuell laufenden Programms darstellt.
Aber diese Datenstruktur ist schwer zu verstehen. Das ist in Ordnung; wir können einfach darüber iterieren:
Beispiel
let args = std::env::args();
for arg in args {
println!("{}", arg);
}
}
Ausgabe:
D:\rust\greeting\target\debug\greeting.exe
Argumente sind im Allgemeinen dafür gedacht, iteriert zu werden, nicht wahr?
Öffnen wir nun die lange unberührte launch.json und suchen wir "args": [], wo wir Laufzeitargumente festlegen können. Wir ändern es in "args": ["first", "second"] und speichern und führen dann das vorherige Programm erneut aus. Die Ausgabe:
D:\rust\greeting\target\debug\greeting.exe first second
Als echtes Kommandozeilenprogramm haben wir es nie wirklich verwendet. Als Sprachtutorial werden wir hier nicht beschreiben, wie man Rust-Programme von der Kommandozeile aus ausführt. Aber wenn Sie ein gut ausgebildeter Entwickler sind, sollten Sie den Speicherort der ausführbaren Datei finden können. Sie können versuchen, in das Verzeichnis zu wechseln und Kommandozeilenbefehle zu verwenden, um den Empfang von Kommandozeilenumgebungsargumenten durch das Programm zu testen.
Kommandozeileneingabe
In früheren Kapiteln wurde ausführlich beschrieben, wie man die Kommandozeilenausgabe verwendet, was für das Erlernen einer Sprache notwendig ist, da Programme ohne Ausgabe nicht debuggt werden können. Das Abrufen von Eingabeinformationen von der Kommandozeile ist für ein Kommandozeilenprogramm jedoch weiterhin recht wichtig.
In Rust stellt das Modul std::io Funktionen im Zusammenhang mit der Standardeingabe bereit (die als Kommandozeileneingabe betrachtet werden kann):
Beispiel
fn main() {
let mut str_buf = String::new();
stdin().read_line(&mut str_buf)
.expect("Failed to read line.");
println!("Your input line is \n{}", str_buf);
}
Die VSCode-Umgebung dazu zu bringen, Kommandozeileneingabe zu unterstützen, ist eine sehr umständliche Angelegenheit, die plattformübergreifende Probleme und Probleme mit der Nicht-Debuggierbarkeit mit sich bringt. Deshalb führen wir das Programm direkt im VSCode-Terminal aus. Führen Sie es über die Kommandozeile aus:
D:\rust\greeting> cd ./target/debug D:\rust\greeting\target\debug> ./greeting.exe EXAMPLE Your input line is EXAMPLE
std::io::Stdio enthält die Methode read_line, mit der eine Zeile eines Strings in einen Puffer eingelesen werden kann. Der Rückgabewert ist das Result-Enum, das verwendet wird, um Fehler zu übermitteln, die beim Lesen auftreten; daher werden die Funktionen expect oder unwrap häufig zur Fehlerbehandlung verwendet.
Hinweis: Derzeit bietet die Rust-Standardbibliothek noch keine Methode, um Zahlen oder formatierte Daten direkt von der Kommandozeile zu lesen. Wir können eine Zeile als String einlesen und Funktionen zum Parsen von Strings verwenden, um die Daten zu verarbeiten.
Dateilesen
Wir erstellen eine Datei text.txt im Verzeichnis D:\ des Computers mit folgendem Inhalt:
This is a text file.
Dies ist ein Programm, das den Inhalt einer Textdatei in einen String einliest:
Beispiel
fn main() {
let text = fs::read_to_string("D:\\text.txt").unwrap();
println!("{}", text);
}
Ausgabe:
This is a text file.
In Rust ist das Einlesen einer ganzen Datei, die in den Speicher passt, eine äußerst einfache Aufgabe. Die Methode read_to_string im Modul std::fs kann das Lesen einer Textdatei problemlos erledigen.
Wenn es sich bei der zu lesenden Datei jedoch um eine Binärdatei handelt, können wir die Funktion std::fs::read verwenden, um eine Sammlung vom Typ u8 einzulesen:
Beispiel
fn main() {
let content = fs::read("D:\\text.txt").unwrap();
println!("{:?}", content);
}
Ausgabe:
[84, 104, 105, 115, 32, 105, 115, 32, 97, 32, 116, 101, 120, 116, 32, 102, 105, 108, 101, 46]
Die beiden obigen Methoden sind einmalige Lesevorgänge, die sich sehr gut für die Entwicklung von Webanwendungen eignen. Für einige Low-Level-Programme ist die traditionelle strombasierte Lesemethode jedoch nach wie vor unersetzlich, da die Dateigröße in den meisten Fällen die Speicherkapazität bei Weitem überschreiten kann.
Lesen von Dateiströmen in Rust:
Beispiel
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);
}
Ausgabe:
[84, 104, 105, 115, 32] [105, 115, 32, 97, 32]
Die File-Klasse im Modul std::fs ist eine Klasse, die Dateien beschreibt und zum Öffnen von Dateien verwendet werden kann. Nach dem Öffnen einer Datei können wir die read-Methode von File verwenden, um die nächsten Bytes der Datei in einem Stream in einen Puffer (der Puffer ist ein u8-Array) einzulesen, wobei die Anzahl der gelesenen Bytes gleich der Länge des Puffers ist.
Hinweis: VSCode hat derzeit nicht die Möglichkeit, Standardbibliotheksreferenzen automatisch hinzuzufügen, daher können manchmal Fehler wie "function or method does not exist" durch Probleme mit Standardbibliotheksreferenzen verursacht werden. Wir können die Dokumentationskommentare der Standardbibliothek (die beim Darüberfahren mit der Maus erscheinen) überprüfen, um die Standardbibliothek manuell hinzuzufügen.
Die open-Methode von std::fs::File öffnet eine Datei im "read-only"-Modus, und es gibt keine entsprechende close-Methode, weil der Rust-Compiler die Datei automatisch schließen kann, wenn sie nicht mehr verwendet wird.
Schreiben in Dateien
Das Schreiben in Dateien wird in einmaliges Schreiben und Stream-Schreiben unterteilt. Für das Stream-Schreiben muss die Datei geöffnet werden, und es gibt zwei Möglichkeiten, sie zu öffnen: "create" und "append".
Einmaliges Schreiben:
Beispiel
fn main() {
fs::write("D:\\text.txt", "FROM RUST PROGRAM")
.unwrap();
}
Das ist so einfach und bequem wie einmaliges Lesen. Nach dem Ausführen des Programms wird der Inhalt der Datei D:\text.txt in FROM RUST PROGRAM umgeschrieben. Verwenden Sie einmaliges Schreiben daher mit Vorsicht! Denn es löscht den Dateiinhalt direkt (egal wie groß die Datei ist). Wenn die Datei nicht existiert, wird sie erstellt.
Wenn Sie Dateiinhalt streamweise schreiben möchten, können Sie die Methode create von std::fs::File verwenden:
Beispiel
use std::fs::File;
fn main() {
let mut file = File::create("D:\\text.txt").unwrap();
file.write(b"FROM RUST PROGRAM").unwrap();
}
Dieses Programm entspricht dem vorherigen.
Hinweis: Die geöffnete Datei muss in einer veränderlichen Variable gespeichert werden, um die Methoden von File verwenden zu können!
Es gibt keine statische Methode append in der Klasse File, aber wir können OpenOptions verwenden, um eine Datei mit einer spezifischen Methode zu öffnen:
Beispiel
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(())
}
Nach dem Ausführen wird der Inhalt der Datei D:\text.txt zu:
FROM RUST PROGRAM APPEND WORD
OpenOptions ist eine flexible Möglichkeit, Dateien zu öffnen. Es kann Öffnungsberechtigungen festlegen. Zusätzlich zur Append-Berechtigung gibt es auch Lese- und Schreibberechtigungen. Wenn wir eine Datei mit Lese- und Schreibberechtigungen öffnen möchten, können wir schreiben:
Beispiel
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(())
}
Nach dem Ausführen wird der Inhalt der Datei D:\text.txt zu:
COVERRUST PROGRAM APPEND WORDAndere Erweiterungen