Fichiers et IO Rust

Ce chapitre présente le langage Rust I/Opération O.

Recevoir des paramètres en ligne de commande

Un programme en ligne de commande est la forme d'existence la plus fondamentale d'un programme informatique, presque tous les systèmes d'exploitation supportent les programmes en ligne de commande et basent l'exécution des programmes visuels sur le mécanisme en ligne de commande.

Un programme en ligne de commande doit être capable de recevoir des paramètres d'environnement en ligne de commande, ces paramètres sont souvent séparés par des espaces après une commande en ligne.

Dans de nombreux langages (comme Java et C/C++Les paramètres d'environnement sont passés au programme à travers les paramètres de la fonction principale (souvent un tableau de chaînes de caractères), mais dans Rust, la fonction principale est une fonction sans paramètres, les paramètres d'environnement doivent être extraits par le développeur via le module std::env, le processus est très simple :

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

Maintenant, exécutez directement le programme :

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

Il se peut que le résultat que vous obtenez soit beaucoup plus long que cela, ce qui est normal, ce résultat contient une structure Args avec un tableau inner, qui ne contient qu'une seule chaîne de caractères, représentant l'emplacement du programme en cours d'exécution.

Mais cette structure de données est difficile à comprendre, pas de souci, nous pouvons simplement l'itérer :

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

Résultat de l'exécution :

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

Les paramètres généraux sont généralement utilisés pour être itérés, n'est-ce pas ?

Maintenant, ouvrons le fichier launch.json que nous n'avons pas touché depuis longtemps, trouvez "args": [], ici vous pouvez configurer les paramètres d'exécution, nous l'écrivons "args": ["first", "second"] , puis sauvegarder et exécuter à nouveau le programme précédent, le résultat de l'exécution :

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

En tant que programme en ligne de commande véritable, nous ne l'avons jamais utilisé réellement, et en tant que manuel de langage, nous ne décrirons pas ici comment exécuter un programme Rust en ligne de commande. Mais si vous êtes un développeur 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 pour tester si le programme reçoit les paramètres d'environnement en ligne de commande.

Entrée en ligne de commande

Les chapitres précédents ont détaillé comment utiliser la sortie en ligne de commande, c'est dû aux besoins de l'apprentissage du langage, sans sortie, il est impossible de déboguer le programme. Mais obtenir des informations à partir de la ligne de commande est toujours très important pour un programme en ligne de commande.

En Rust, le module std::io fournit les fonctionnalités liées à l'entrée standard (qui peut être considéré comme l'entrée en ligne de commande) :

use std::io::stdin;
fn main() {
let mut str_buf = String::new();
　　　　stdin().read_line(&mut str_buf)
　　　　　　　　.expect("Échec de la lecture de la ligne.");
　　　　println!("Votre ligne d'entrée est 
{}", str_buf);
}

Il est très fastidieux de faire en sorte que l'environnement VSCode supporte l'entrée en ligne de commande, cela implique des problèmes de plateformes et des problèmes qui ne peuvent pas être débogués, donc nous exécutons directement le programme dans le terminal de VSCode. Exécutez la commande en ligne de commande :

D:\rust\greeting> cd ./target/debug
D:\rust\greeting\target\debug> ./greeting.exe
w3codebox
Votre ligne d'entrée est　
w3codebox

Le paquet std::io::Stdio contient la méthode read_line pour lire une ligne de chaîne dans un tampon, le retour est toujours un type d'énumération Result, utilisé pour transmettre les erreurs qui peuvent survenir lors de la lecture, donc les fonctions expect ou unwrap sont souvent utilisées pour traiter les erreurs.

Remarque：Actuellement, la bibliothèque standard de Rust ne fournit pas de méthode directe pour lire des nombres ou des données formatées depuis la ligne de commande, nous pouvons lire une ligne de chaîne de caractères et utiliser des fonctions de reconnaissance de chaîne pour traiter les données.

Lecture de fichier

Nous créons un fichier text.txt dans le répertoire D:\ du disque dur de l'ordinateur, avec le contenu suivant :

Ceci est un fichier texte.

Voici un programme qui lit le contenu d'un fichier texte dans une chaîne de caractères :

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

Résultat de l'exécution :

Ceci est un fichier texte.

Lire un fichier qui peut être contenu dans la mémoire en Rust est une tâche extrêmement simple, la méthode read_to_string du module std::fs peut lire un fichier texte de manière aisée.

Mais si le fichier à lire est un fichier binaire, nous pouvons utiliser la fonction std::fs::read pour lire u8 ensemble de types :

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

Résultat de l'exécution :

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

Ces deux méthodes de lecture en une seule fois sont très appropriées pour le développement d'applications Web. Cependant, pour certains programmes de bas niveau, le mode de lecture traditionnelle en mode flux reste insubstituable, car dans de nombreux cas, la taille du fichier peut être bien au-delà de la capacité de la mémoire.

Mode de lecture de flux de fichier en Rust :

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);
}

Résultat de l'exécution :

[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 certains octets du fichier en mode flux dans le tampon (le tampon est un u8 d'octets), le nombre d'octets lus est égal à la longueur du tampon.

Attention : VSCode ne dispose pas encore de la fonctionnalité d'ajout automatique des références aux bibliothèques standard, donc parfois, les erreurs de "fonction ou méthode introuvable" peuvent être dues à des problèmes de références aux bibliothèques standard. Nous pouvons consulter les commentaires de la documentation de la bibliothèque standard (sous le curseur) pour ajouter manuellement la bibliothèque.

La méthode open de std::fs::File ouvre le fichier en lecture seule et n'a pas de méthode close associée, car le compilateur Rust peut fermer automatiquement le fichier lorsque celui-ci n'est plus utilisé.

Écriture de fichier

L'écriture de fichier se divise en écriture en une seule fois et écriture en mode flux. L'écriture en mode flux nécessite d'ouvrir le fichier, et il existe deux méthodes d'ouverture : "créer" (create) et "ajouter" (append).

Écriture en une seule fois :

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

C'est aussi simple et pratique que de lire en une seule fois. Après l'exécution du programme, le contenu du fichier D:\text.txt sera réécrit en FROM RUST PROGRAM . Donc, soyez prudent lors de l'écriture en une seule fois ! Car cela supprimera directement le contenu du fichier (quel que soit son taille). Si le fichier n'existe pas, il sera créé.

Si vous souhaitez écrire le contenu d'un fichier de manière fluide, vous pouvez utiliser la méthode create de std::fs::File :

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();
}

Ce programme est équivalent au programme précédent.

RemarqueLes fichiers ouverts doivent être stockés dans une variable mutable pour 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 :

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(())
}

Après exécution, le contenu du fichier D:\text.txt deviendra :

FROM RUST PROGRAM APPEND WORD

OpenOptions est une méthode flexible pour ouvrir un fichier, elle peut configurer les permissions d'ouverture, en plus de la permission d'ajout, elle comprend également les permissions de lecture et d'écriture. Si nous voulons ouvrir un fichier en lecture-écriture, nous pouvons écrire ainsi :

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 WORD