Un guide pour travailler avec des fichiers texte dans Rust

Les hautes performances et la sécurité de la mémoire de Rust, combinées à la prise en charge des expressions régulières et des E/S de fichiers efficaces opérations, permettent un traitement de texte et de données convaincant, faisant de Rust un excellent langage pour travailler avec du texte des dossiers.

Les fichiers texte sont une source de données partagée pour les applications, et Rust fournit un ensemble d'outils robustes pour travailler avec des fichiers texte dans la bibliothèque standard.

Travailler avec des fichiers texte dans Rust

La bibliothèque standard de Rust fournit plusieurs modules pour lire, écrire et manipuler des fichiers, y compris des fichiers texte.

Travailler avec des fichiers texte dans Rust implique de lire les données d'un fichier, d'utiliser les données en mémoire, puis de réécrire les données modifiées dans le fichier.

Rust fournit la fonction intégrée fs module pour travailler avec les fichiers et le système de fichiers. Le

fs Le module fournit des fonctions et des types que vous pouvez utiliser pour ouvrir, lire, écrire et manipuler des fichiers et des répertoires, y compris des fichiers texte.

Fonctions populaires dans le fs le module comprend le fs:: Fichier:: ouvrir fonction d'ouverture de fichiers pour les opérations de lecture, la fs:: Fichier:: créer pour créer des fichiers, et le fs:: écrire fonction d'écriture de données dans des fichiers.

Le fs module fournit également des fonctions telles que le fs:: remove_file fonction de suppression de fichiers, la fs:: create_dir fonction de création de répertoires, et la fs:: read_dir fonction de lecture de fichiers dans un répertoire.

Le fs module est polyvalent, et vous pouvez utiliser le fs module pour fonctionner avec la plupart des types de fichiers, y compris les fichiers texte.

Lire des fichiers texte dans Rust

Vous devez ouvrir un fichier texte pour lire le fichier. Vous utiliserez le fs:: Fichier:: ouvrir fonction pour ouvrir le fichier avant l'opération de lecture.

Exécutez ces commandes pour créer un fichier texte et écrivez une phrase dans le fichier à partir de votre ligne de commande.

touchez input.txt
echo "Nous sommes des passionnés de technologie qui ont pour mission d'enseigner au monde comment utiliser et comprendre la technologie dans leur vie. Téléphones, ordinateurs portables, gadgets, applications, logiciels, sites Web, services si cela peut améliorer votre vie, nous vous montrerons vous donne tous les trucs, astuces et techniques que vous devez connaître pour tirer le meilleur parti de ce que vous avez." > entrée.txt

Maintenant que vous avez un fichier texte existant avec un contenu pour l'opération de lecture, vous pouvez écrire du code Rust pour lire le contenu du fichier.

Voici comment vous pouvez lire à partir du entrée.txt déposer:

utiliser std:: fs:: Fichier ;
utiliser std:: io ::{BufRead, BufReader} ;
fnprincipal() -> std:: io ::Résultat {
// Ouvre le fichier en lecture
laisser fichier = Fichier:: ouvrir("entrée.txt")?;
// Crée un lecteur tamponné pour lire le fichier
laisser lecteur = BufReader:: nouveau (fichier);
// Lit le fichier ligne par ligne
pour doubler dans lecteur.lines() {
imprimez !("{}", doubler?);
 }
D'accord(())
}

Le principal fonction renvoie le résultat de l'opération. Le déposer variable est l'instance de fichier ouvert que le nouveau fonction de la BufLire prend en charge pour créer un lecteur tamponné pour lire le fichier.

La structure de contrôle de la boucle for parcourt le fichier et imprime chaque ligne du fichier à la console avec le imprimez ! macro.

Écrire dans des fichiers texte dans Rust

Vous devrez créer un nouveau fichier avec le fs:: Fichier:: créer fonction (si le fichier n'existe pas) pour écrire dans un fichier texte.

Voici comment vous pouvez créer et écrire des fichiers texte dans Rust :

utiliser std:: fs:: Fichier ;
utiliser std:: io:: {BufWriter, Écrire} ;
fnprincipal() -> std:: io ::Résultat {
// Crée un nouveau fichier pour l'écriture
laisser fichier = Fichier:: créer("sortie.txt")?;
// Crée un écrivain tamponné pour écrire dans le fichier
laissermuet writer = BufWriter:: new (fichier);
// Écrit des données dans le fichier
 écrivain.write_all(b"Bonjour, tout le monde !\n")?;
 écrivain.write_all(b"La rouille est géniale.\n")?;
// Videz le graveur pour vous assurer que toutes les données sont écrites sur le disque
 écrivain.flush(?);
imprimez !("Opération d'écriture réussie");
D'accord(())
}

Le déposer variable est une instance de la création sortie.txt dossier, et le écrivain variable est une instance d'écriture tamponnée pour écrire dans le fichier.

Le écrire_tout fonction écrit des données dans le fichier, et la affleurer fonction vide l'écrivain.

Voici le résultat de l'exécution de la fonction main :

Vous pouvez utiliser des fichiers texte pour plusieurs opérations

Les fichiers texte sont légers et pratiques à des fins multiples, des fichiers de configuration à l'échange de données, à la journalisation et au traitement de texte. Lorsque vous créez des applications dans Rust ou dans tout autre langage de programmation comme Go, vous pouvez explorer d'autres cas d'utilisation des fichiers texte pour faciliter vos workflows de développement.