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

fn main() {
    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

fn main() {
    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

use std::io::stdin;

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

use std::fs;

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

use std::fs;

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

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

use std::fs;

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::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 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::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 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 WORD
Autres extensions