Pour accédez aux fichiers, nous avons parlé du package io/ioutil qui offre des fonctions simples. Mais si vous souhaitez contrôler un peu plus précisément l'accès aux fichiers, vous allez probablement utiliser le package os.

Le package os fournit également un ensemble de fonctions pour accéder aux fichiers avec davantage de contrôle. Avec io/ioutil, vous pouvez lire le fichier entier et écrire le fichier entier.

Avec le package os, vous pouvez agir plus précisément : lire un peu, écrire un peu, faire différentes choses. Voici donc quelques-unes des fonctions qu'il contient.

Pour ouvrir un fichier on utilise os.Open(). On passe en argument le nom du fichier et elle renvoi un descripteur de fichier : une structure File représentant un fichier que vous pourrez utiliser pour accéder au fichier.

La fonction os.Close() ferme le fichier lorsque vous avez terminé.

os.Read() lit un fichier et rempli le tableau d'octets passé en paramètre. Ainsi, vous pouvez contrôler la quantité que vous lisez, contrairement à ioutil.ReadFile() où vous deviez lire le fichier entier. Si vous ne voulez en lire que dix octets, vous pouvez créer un tableau d'octets de taille 10, et le transmettre à os.Read(), qui remplira ces 10 octets.

La fonction os.Write() se comporte de la même manière : vous pouvez prendre un tableau de n octets et les écrire dans le fichier.

Voici donc un exemple de lecture de fichier à l'aide du package os.

f, err := os.Open("dt.txt")
 
barr := make( []byte, 10 )
 
nb, err := f.Read( barr )
 
f.Close()

La première chose à faire est d'ouvrir le fichier, on appelle os.Open() avec en paramètre le nom du fichier (pour l'exemple “dt.txt”). La fonction renvoie le descripteur de fichier f que nous pourrons utiliser pour accéder au fichier.

Nous souhaitons lire le fichier et placer son contenu dans un tableau d'octets. Ici on fait le choix de lire par groupe de 10 octets de ce fichier : on peut créer un tableau d'octets, barr via l'appel à make() : on obtient un tableau de 10 octets vides.

On appelle f.Read(). f est le descripteur renvoyé par os.Open(). On passe le tableau d'octets barr comme argument. La fonction rempli ce tableau d'octets avec les premiers octets du fichier.

Notez que si on appelle à nouveau la fonction Read() avec le même tableau d'octets, il remplira le tableau d'octets avec les 10 octets suivants. À chaque fois, la tête de lecture est déplacée.

On a lu les 10 premiers octets. Si je relis, ce seront les 10 octets suivants jusqu'à ce qu'on ferme et que je réinitialise la tête.

Cette fonction renvoie deux choses : une erreur, s'il y en a une, le nombre d'octets lus sinon. Le nombre d'octets peut être égal à la taille du tableau d'octets, mais ce n'est pas obligatoire. Vous pouvez avoir ce que l'on appelle une lecture courte. Peut-être que le tableau d'octets est de taille 10, mais qu'il ne reste que cinq jeux d'octets dans le fichier, alors vous n'en lisez que cinq. Dans ce cas la variable nb vaudrait 5.

Ensuite, lorsque vous avez fini de lire, il vous suffit d'appeler la fonction f.close(), qui ferme le fichier et réinitialise la position de la tête de lecture pour le prochain usage.

L'exemple suivant montre l'utilisation de la fonction Write() du package os.

f, err := os.Create("outfile.txt")
 
barr := []byte{1,2,3}
 
nb, err := f.Write( barr )
nb, err := f.WriteString( "Hi" )

Nous créons donc d'abord le fichier avec os.Create(). Nous aurions pu ouvrir un fichier existant, pour y ajouter des données. Dans ce cas, nous allons simplement créer un fichier “outfile.txt”. Nous obtenons le descripteur de fichier f qui fait référence à ce fichier.

Ensuite, on définit une slice (définition littérale) barr. Nous appelons f.write(), nous lui passons le tableau d'octets et elle écrit simplement ces trois octets dans le fichier.

Il existe une autre fonction appelée WriteString() qui prend une chaîne entière au lieu d'un tableau d'octets : elle prend une chaîne explicite (séquence unicode) et l'écrit.

◁ Précédent | ⌂ Retour au sommaire