En tant que langage de programmation, Go dispose d'un large éventail de fonctionnalités intégrées, notamment la possibilité de créer, de lire et d'écrire des fichiers tels que des fichiers texte (.txt).

Les fichiers sont des éléments importants de notre vie quotidienne dans le monde moderne. Les fichiers texte sont utiles pour stocker des données structurées lisibles par l'homme sans utiliser de logiciels ou de bases de données externes.

Si vous vous demandez comment vous pourriez commencer à manipuler des fichiers texte dans Go, cet article est fait pour vous.

Le forfait bufio en Go

Le bufio package, qui fait partie de la bibliothèque standard de Go, est utilisé pour les opérations d'entrée et de sortie tamponnées, d'où son nom. Le bufio paquet s'appuie sur le io. Lecteur et io. Écrivain interfaces, qui sont largement utilisées dans la mise en œuvre de la majorité des packages standard de Go.

Le bufio package va encore plus loin en implémentant la mise en mémoire tampon, ce qui le rend utile pour les opérations d'E/S impliquant des données textuelles.

Pour utiliser le bufio package dans votre programme, vous devez l'importer avec d'autres packages.

importer (
"fmt"
"bufio"
)

Vous avez probablement entendu quand vous j'ai commencé avec Go qu'il est livré avec tout ce dont vous pourriez avoir besoin en tant que programmeur. Pour une communication directe avec votre système d'exploitation, il existe un package appelé os qui fournit des fonctions indépendantes de la plate-forme.

Le os et bufio les packages rendent la manipulation des fichiers texte incroyablement simple.

Bien que la grande majorité des os Les fonctions du package sont de type Unix, elles utilisent toutes le style Go de gestion des erreurs, ce qui simplifie la lecture des messages d'erreur et le débogage du code.

Alors, comment manipulez-vous les fichiers contenant du texte dans Go ?

Comment lire des données à partir d'un fichier texte

Pour lire des données à partir de fichiers texte, vous devez appeler le os paquets Ouvrir() qui accepte le nom du fichier à lire en paramètre. Une autre méthode pour obtenir le fichier consiste à utiliser le Fichier ouvert() fonction.

La différence majeure entre Ouvrir() et Fichier ouvert() est dans leur mise en œuvre. Ouvrir() ouvre un fichier en mode lecture seule (avec le O_RDONLY drapeau), tandis que Fichier ouvert() donne plus de souplesse en acceptant trois paramètres à savoir :

  • Nom de fichier
  • Mode d'ouverture de fichier: les modes d'ouverture de fichier valides sont indiqués dans le tableau ci-dessous.
    Drapeau Signification
    O_RDONLY Ouvre le fichier en mode lecture seule
    O_WRONLY Ouvre le fichier en mode écriture seule
    O_RDWR Ouvre le fichier en mode lecture-écriture
    O_APPEND Ajoute des données au fichier lors de l'écriture
    O_CREATE Crée un nouveau fichier s'il n'en existe pas
    O_EXCL Utilisé avec O_CREATE, pour indiquer que le fichier ne doit être créé que s'il n'existe pas
    O_SYNC Ouvre le fichier pour les E/S synchrones
    O_TRUNC Tronquer le fichier à l'ouverture, si possible
  • Autorisations de fichier: identiques à celles bits d'autorisation de fichier sous Linux utilisé pour spécifier les règles d'accès aux fichiers, par exemple, 0777 pour accorder des autorisations de lecture, d'écriture et d'exécution à tous les types d'utilisateurs.

Le code ci-dessous montre comment lire les données d'un fichier texte dans Go en utilisant os. Ouvrir(), et Analyse() qui, dans ce cas, fonctionne dans un Aller pour la boucle.

emballer principal
importer (
"bufio"
"fmt"
"enregistrer"
"os"
)
/**
 CONTENU DU "testfile.txt" déposer.
 Lorem ipsum dolor sit amet
 LOREM IPSUM DOLOR SIT AMET
 Lorem ipsum dolor sit amet
 Lorem ipsum dolor sit amet
 Lorem ipsum dolor sit amet
 Lorem ipsum dolor sit amet
*/
fonction principal(){
 fichier, erreur := os. Ouvrir("testfile.txt")
// une autre méthode utilisant os. Fichier ouvert()
 // fichier, erreur = os. Fichier ouvert("testfile.txt", os. O_RDEULEMENT, 0644)
 si err != néant {
enregistrer.Fatal(se tromper)
 }
reporterdéposer.Fermer()
 fmt. Imprimerln("Fichier ouvert avec succès. Maintenant, lisez le contenu du fichier ligne par ligne :")
 // créer scanner depuis le déposerpourliretextedepuis
 scanner := bufio. NouveauScanner (fichier)
// scanne ou lit les octets de texte ligne par ligne
pourscanner.Analyse() {
fmt.Println(scanner.Texte())
 }
 si erreur := analyseur. Se tromper(); erreur != néant {
enregistrer.Fatal(se tromper)
 }
}

Lorsque vous exécutez le code ci-dessus avec allez exécuter filename.go, il produit la sortie ci-dessous :

Si vous ne transmettez que le nom du fichier et non le chemin d'accès au Ouvrir() ou Fichier ouvert() pour les opérations de lecture, Go suppose que le fichier se trouve dans le répertoire actuel et renvoie une erreur s'il ne le trouve pas. Vous devez transmettre le chemin d'accès au fichier si vous devez travailler avec des fichiers en dehors du répertoire courant.

Comment écrire des données dans un fichier texte

Le bufio package fournit une mise en mémoire tampon Écrivain interface qui stocke des octets de données et les écrit dans un fichier à l'aide d'un Affleurer() fonction.

Le prochain exemple de code est une continuation de celui pour lire un fichier. Dans cet exemple, les données sont écrites dans le testfile.txt en utilisant le O_WRONLY et O_APPEND drapeaux.

Ajoutez les lignes de code suivantes au programme ci-dessus, avant l'accolade fermante du principal() fonction:

// écrit les données de sortie dans le fichier
fichier, erreur = os. OpenFile("testfile.txt", os. O_APPEND|os. O_WRONLY, 0644)
si erreur != néant {
 enregistrer. Fatal (erreur)
}
reporter déposer. Fermer()
fmt. Println("Fichier ouvert avec succès, préparation en cours pour écrire des données dans le fichier...")
// crée un objet Writer tamponné pour écrire des données dans le fichier
textWriter := bufio. NewWriter (fichier)
// écrit la chaîne dans le tampon avant d'enregistrer le fichier.
_, err = textWriter. WriteString("-Ceci est un nouveau texte ajouté au fichier.")
si erreur != néant {
 enregistrer. Fatal (erreur)
}
textWriter. Affleurer()
fmt. Println("Données écrites dans le fichier avec succès...")

La sortie de votre programme complet devrait ressembler à ceci :

Lorsque vous ouvrez le testfile.txt fichier, vous verrez également la nouvelle ligne ajoutée à la fin du fichier, tout comme l'image ci-dessous :

La gestion des fichiers dans Go est facile

Go vous permet de travailler avec une variété de fichiers, pas seulement des fichiers texte. Il existe de nombreuses bibliothèques et fonctions intégrées supplémentaires pour travailler avec différents types de données à partir de fichiers, y compris JSON et CSV.

Pour voir comment ils se comportent différemment selon la situation, vous pouvez expérimenter avec les différents drapeaux et autorisations de fichiers disponibles pour une utilisation avec Fichier ouvert().