On utilise fréquemment les fichiers dans les programmes pour échanger des données. Nous allons aborder ici la façon dont Golang nous permet d'accéder aux fichiers.

L'accès aux fichiers (c'est le cas dans tous les languages), est linéaire et non un accès aléatoire. La raison est historique car les fichiers, lorsqu'ils ont été définis, étaient en fait stockés sur des bandes : des cassettes physiques à bande magnétique.

Pour accéder aux données sur la cassette, vous faites physiquement tourner la bande, vous la déroulez, c'est un accès linéaire. Cela signifie que le début du fichier se trouve à un point de la bande, la fin du fichier se trouve plus loin, à un autre point de la bande. Donc, si vous voulez y accéder, vous devez commencer, lire un point de la cassette, puis tourner la cassette et lire le point suivant. Tournez le ruban, lire le point suivant, et ainsi de suite. Il s'agit donc toujours d'un accès linéaire.

Cette opération mécanique qui consiste à tourner physiquement la cassette pour accéder à la partie suivante du fichier, définit un accès linéaire. Si vous voulez simplement accéder à une information au début puis à une autre donnée à la fin, cela vous fait perdre beaucoup de temps car il faut faire défiler mécaniquement toute la bande: votre lecture est linéaire.

Pour accélérer ce temps d'accès, en général on lit également les données à proximité. C' est ainsi que se passe encore aujourd'hui encore l'accès aux fichiers.

Notons que nous n'avons pas nécessairement cette contrainte d'accès linéaire. Les disque-durs physiques ont toujours un accès linéaire : il y a encore des pistes, et il faut les parcourir en entier. Mais un fichier peut se trouver sur un périphérique à accès aléatoire comme une mémoire flash ou un disque SSD.

Il s'agit en fait d'un dispositif à accès aléatoire, mais la façon dont nous accédons aux fichiers depuis les programmes est identique et tout se passe comme s'il s'agissait d'un dispositif à accès linéaire.

Pour accéder aux fichiers, Golang (comme d'autre langages) propose un ensemble d'opérations de base :

• Open : elle retourne un contrôleur pour accéder au fichier : vous devez d'abord ouvrir le fichier ;
• Read : On utilise ensuite une fonction de lecture qui permet de lire des octets du fichier sous la forme d'un tableau d'octets ;
• Write : qui permet d'écrire les données à partir d'un tableau d'octets et de les enregistrer dans un fichier ;
• Close : Lorsque vous avez terminé, vous fermez le fichier parce que vous avez fini de le lire ou d'y accéder ;
• Seek : permet de déplacer votre tête de lecture. Cela confirme qu'il s'agit d'un accès linéaire : vous lisez du début à la fin, mais parfois vous devez vraiment sauter à un certain point et c'est Seek qui permet de le faire.

Ce sont des fonctions très courantes que vous retrouvez dans n'importe quelle langage pour accéder aux fichiers.

Il existe plusieurs packages dans Go, qui vous permettent d'accéder aux fichiers. Nous allons commencer par le package ioutil. Le package ioutil possède quelques fonctions élémentaires d'accès aux fichiers.

Élémentaires mais simples et agréables à utiliser. Si ce type d'accès est suffisant pour votre application, ioutil conviendra parfaitement.

helloReadFile.go

package main
 
import (
        "fmt"
        "io/ioutil"
)
var FILENAME string = "/tmp/test.txt"
 
func main(){
   dat, _:= ioutil.ReadFile( FILENAME )
 
   fmt.Printf( "%s", dat )
}

Notons qu' ioutil.ReadFile() prend en argument le nom du fichier que vous souhaitez lire. Cela peut être un fichier comme test.txt. Elle renvoie deux choses : les données (essentiellement un tableau d'octets), puis un code d'erreur.

Un valeur d'erreur non nulle est produite uniquement s'il y a une erreur de lecture. Le traitement de la fonction est assez simple : Il lit le fichier entier et renvoie le contenu de l'ensemble du fichier dans un tableau d'octets : vous pouvez alors manipuler le tableau d'octets.

Lorsque vous utilisez ioutil.ReadFile(), vous n'avez pas à effectuer d'ouverture ou de fermeture explicite avec des appels à Open() ou Close(). Tout cela est intégré à la fonction.

Ce mode d'ouverture peut cependant poser problème sur des fichiers volumineux. Cela ne provoquera pas d'erreur, mais les fichiers peuvent être gigantesques. Un disque peut contenir des fichiers de plusieurs téraoctets, ainsi vous pouvez avoir des fichiers qui occupent réellement la majeure partie de votre mémoire parce que lorsque vous lisez un fichier, les données sont copiées dans la RAM, dans sa mémoire principale. Cependant la mémoire principale est beaucoup plus limitée en taille : le disque peut contenir des téraoctets, alors que la RAM se compte en général en Gigaoctets.

Ainsi, je pourrais avoir un fichier de huit gigaoctets sur mon disque, que j'essaye de lire. Si je lis tout ce fichier d'un coup, j'utilise toute ma RAM et la mémoire centrale de ma machine sera saturée. Je ne pourrais rien exécuter en plus car j'ai épuisé toute la mémoire disponible.

Ainsi, sur des fichiers trop volumineux, ReadFile() ne pourra pas être utilisée. Mais si vos fichiers sont suffisamment petits pour ne pas monopoliser toute la mémoire, ReadFile() convient parfaitement. Vous pouvez tout lire en une seule fois.

Le package io/ioutil possède également une fonction WriteFile() qui est complémentaire à ReadFile(). Elle prend trois arguments. Le premier argument est le nom du fichier dans lequel vous allez écrire. Le deuxième argument est le tableau d'octets ou une chaîne de caractères, et le troisième argument fournit les autorisations d'accès (à la façon des systèmes UNIX).

Notez cependant que WriteFile() n'est pas flexible. La fonction se contente d'écrire le contenu passé en paramètre dans un fichier. Pour modifier ou ajouter des données à un fichier existant il faudra s'appuyer sur d'autres fonctions.

◁ Précédent | ⌂ Retour au sommaire | Suivant ▷