Fichiers et E/S de Rust
Ce chapitre présente les opérations d'E/S du langage Rust.
Réception des arguments de ligne de commande
Les programmes en ligne de commande sont la forme la plus basique des programmes informatiques. Presque tous les systèmes d'exploitation prennent en charge les programmes en ligne de commande et basent l'exécution des programmes visuels sur le mécanisme de ligne de commande.
Un programme en ligne de commande doit pouvoir recevoir des arguments depuis l'environnement de ligne de commande. Ces arguments apparaissent généralement après une commande en ligne de commande et sont séparés par des espaces.
Dans de nombreux langages (comme Java et C/C++), les arguments d'environnement sont passés au programme comme paramètres de la fonction main (souvent un tableau de chaînes de caractères). Cependant, en Rust, la fonction main est une fonction sans paramètres, et les arguments d'environnement doivent être récupérés par le développeur via le module std::env. Le processus est très simple :
Exemple
let args = std::env::args();
println!("{:?}", args);
}
Maintenant, exécutez le programme directement :
Args { inner: ["D:\\rust\\greeting\\target\\debug\\greeting.exe"] }Peut-être que le résultat que vous obtenez est bien plus long que celui-ci, ce qui est normal. Dans ce résultat, la structure Args contient un tableau interne qui ne contient qu'une seule chaîne, représentant l'emplacement du programme en cours d'exécution.
Mais cette structure de données est difficile à comprendre. Ce n'est pas grave ; nous pouvons simplement la parcourir :
Exemple
let args = std::env::args();
for arg in args {
println!("{}", arg);
}
}
Sortie :
D:\rust\greeting\target\debug\greeting.exe
Les arguments sont généralement faits pour être parcourus, non ?
Maintenant, ouvrons le launch.json que nous n'avons pas touché depuis longtemps, trouvons "args": [], où nous pouvons définir les arguments d'exécution. Nous allons le remplacer par "args": ["first", "second"], puis enregistrer et exécuter à nouveau le programme précédent. La sortie :
D:\rust\greeting\target\debug\greeting.exe first second
En tant que véritable programme en ligne de commande, nous ne l'avons en fait jamais utilisé. En tant que tutoriel de langage, nous ne décrirons pas ici comment exécuter des programmes Rust depuis la ligne de commande. Mais si vous êtes un développeur bien formé, vous devriez pouvoir trouver l'emplacement du fichier exécutable. Vous pouvez essayer d'entrer dans le répertoire et d'utiliser des commandes en ligne de commande pour tester la réception des arguments d'environnement de ligne de commande par le programme.
Entrée en ligne de commande
Les chapitres précédents ont décrit en détail comment utiliser la sortie en ligne de commande, ce qui est nécessaire pour l'apprentissage d'un langage, car les programmes ne peuvent pas être débogués sans sortie. Cependant, obtenir des informations d'entrée à partir de la ligne de commande reste très important pour un programme en ligne de commande.
En Rust, le module std::io fournit des fonctionnalités liées à l'entrée standard (qui peut être considérée comme une entrée en ligne de commande) :
Exemple
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);
}
Faire en sorte que l'environnement VSCode prenne en charge l'entrée en ligne de commande est une affaire très fastidieuse, impliquant des problèmes multiplateformes et des problèmes non débogables, nous allons donc exécuter le programme directement dans le terminal VSCode. Exécutez-le depuis la ligne de commande :
D:\rust\greeting> cd ./target/debug D:\rust\greeting\target\debug> ./greeting.exe EXAMPLE Your input line is EXAMPLE
std::io::Stdio contient la méthode read_line, qui peut lire une ligne de chaîne dans un tampon. La valeur de retour est l'énumération Result, utilisée pour transmettre les erreurs qui se produisent lors de la lecture, donc les fonctions expect ou unwrap sont couramment utilisées pour gérer les erreurs.
Remarque: Actuellement, la bibliothèque standard de Rust ne fournit pas encore de méthode pour lire directement des nombres ou des données formatées à partir de la ligne de commande. Nous pouvons lire une ligne de chaîne et utiliser des fonctions d'analyse de chaîne pour traiter les données.
Lecture de fichier
Nous créons un fichier text.txt dans le répertoire D:\ de l'ordinateur, avec le contenu suivant :
This is a text file.
Voici un programme qui lit le contenu d'un fichier texte dans une chaîne de caractères :
Exemple
fn main() {
let text = fs::read_to_string("D:\\text.txt").unwrap();
println!("{}", text);
}
Sortie :
This is a text file.
En Rust, lire un fichier entier qui tient en mémoire est une tâche extrêmement simple. La méthode read_to_string du module std::fs peut facilement terminer la lecture d'un fichier texte.
Mais si le fichier à lire est un fichier binaire, nous pouvons utiliser la fonction std::fs::read pour lire une collection de type u8 :
Exemple
fn main() {
let content = fs::read("D:\\text.txt").unwrap();
println!("{:?}", content);
}
Sortie :
[84, 104, 105, 115, 32, 105, 115, 32, 97, 32, 116, 101, 120, 116, 32, 102, 105, 108, 101, 46]
Les deux méthodes ci-dessus sont des lectures uniques, ce qui convient très bien au développement d'applications web. Cependant, pour certains programmes de bas niveau, la méthode traditionnelle de lecture basée sur les flux reste irremplaçable, car dans la plupart des cas, la taille du fichier peut largement dépasser la capacité de la mémoire.
Lecture de fichiers en flux en Rust :
Exemple
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);
}
Sortie :
[84, 104, 105, 115, 32] [105, 115, 32, 97, 32]
La classe File du module std::fs est une classe qui décrit les fichiers et peut être utilisée pour ouvrir des fichiers. Après avoir ouvert un fichier, nous pouvons utiliser la méthode read de File pour lire les octets suivants du fichier dans un tampon (le tampon est un tableau u8) en flux, le nombre d'octets lus étant égal à la longueur du tampon.
Remarque : VSCode n'a actuellement pas la capacité d'ajouter automatiquement des références à la bibliothèque standard, donc parfois des erreurs comme « la fonction ou la méthode n'existe pas » peuvent être causées par des problèmes de référence à la bibliothèque standard. Nous pouvons consulter les commentaires de documentation de la bibliothèque standard (qui apparaissent lorsqu'on la survole) pour ajouter manuellement la bibliothèque standard.
La méthode open de std::fs::File ouvre un fichier en mode « lecture seule », et il n'existe pas de méthode close correspondante, car le compilateur Rust peut fermer automatiquement le fichier lorsqu'il n'est plus utilisé.
Écriture de fichiers
L'écriture de fichier se divise en écriture en une seule fois et écriture en flux. L'écriture en flux nécessite l'ouverture du fichier, et il existe deux façons de l'ouvrir : « create » et « append ».
Écriture en une seule fois :
Exemple
fn main() {
fs::write("D:\\text.txt", "FROM RUST PROGRAM")
.unwrap();
}
C'est aussi simple et pratique qu'une lecture unique. Après avoir exécuté le programme, le contenu du fichier D:\text.txt sera réécrit en FROM RUST PROGRAM. Par conséquent, utilisez l'écriture unique avec prudence ! Car elle supprimera directement le contenu du fichier (quelle que soit sa taille). Si le fichier n'existe pas, il créera le fichier.
Si vous souhaitez écrire le contenu d'un fichier en flux, vous pouvez utiliser la méthode create de std::fs::File :
Exemple
use std::fs::File;
fn main() {
let mut file = File::create("D:\\text.txt").unwrap();
file.write(b"FROM RUST PROGRAM").unwrap();
}
Ce programme est équivalent au précédent.
Remarque: Le fichier ouvert doit être stocké dans une variable mutable afin d'utiliser les méthodes de File !
Il n'existe pas de méthode statique append dans la classe File, mais nous pouvons utiliser OpenOptions pour ouvrir un fichier avec une méthode spécifique :
Exemple
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(())
}
Après exécution, le contenu du fichier D:\text.txt deviendra :
FROM RUST PROGRAM APPEND WORD
OpenOptions est un moyen flexible d'ouvrir des fichiers. Il peut définir des autorisations d'ouverture. En plus de l'autorisation d'ajout, il existe également des autorisations de lecture et d'écriture. Si nous voulons ouvrir un fichier avec les autorisations de lecture et d'écriture, nous pouvons écrire :
Exemple
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(())
}
Après exécution, le contenu du fichier D:\text.txt deviendra :
COVERRUST PROGRAM APPEND WORDAutres extensions