Lire et écrire dans des fichiers

La gestion des fichiers est une opération courante en programmation. Go propose les packages os et io pour manipuler les fichiers efficacement. Cette section présente les différentes méthodes pour lire et écrire dans des fichiers en Go.

1. Lire un fichier

L’ouverture et la lecture des fichiers sont des opérations fondamentales en programmation. Go offre plusieurs façons de récupérer le contenu d’un fichier en fonction du besoin spécifique du programme. Cette section explore différentes méthodes de lecture de fichiers, en optimisant les performances et la gestion des erreurs.

a. Lire un fichier en entier

Pour un fichier de taille modérée, il est possible de charger son contenu en mémoire en une seule fois. Cette méthode n’est pas adaptée aux fichiers volumineux, car elle risque de saturer la mémoire vive du système.

package main  
 
import (  
    "fmt"  
    "io/ioutil"  
    "log"  
)  
 
func main() {  
    // Lecture complète du fichier  
    content, err := ioutil.ReadFile("example.txt")  
    if err != nil {  
        log.Fatal("Erreur lors de la lecture du fichier :", err)  
    }  
 
    // Affichage du contenu du fichier  
    fmt.Println(string(content))  
}

b. Lire un fichier ligne par ligne

Pour éviter de surcharger la mémoire avec un fichier volumineux, il est préférable de le lire ligne par ligne.

package main  
 
import (  
    "bufio"  
    "fmt"  
    "os"  
)  
 
func main() {  
    // Ouverture du fichier en mode lecture  
    file, err := os.Open("example.txt")  
    if err != nil {  
        fmt.Println("Impossible d'ouvrir le fichier :", err)  
        return...

Gestion des répertoires et manipulation des fichiers

La gestion des fichiers et des répertoires est essentielle en programmation pour organiser, stocker et accéder aux données. Go fournit le package os pour manipuler facilement les répertoires et fichiers.

1. Créer un répertoire

L’organisation des fichiers et répertoires est essentielle pour une bonne gestion des données. Go permet de manipuler facilement les répertoires en créant, structurant et vérifiant leur existence avant toute opération. Cette section explore plusieurs manières de créer un répertoire, en prenant en compte les permissions et la gestion des erreurs.

a. Créer un répertoire simple

La fonction os.Mkdir permet de créer un répertoire à un emplacement donné.

package main  
 
import (  
    "fmt"  
    "os"  
)  
 
func main() {  
    dirName := "new_directory"  
 
    // Création du répertoire avec des permissions spécifiques  
    // 0755 : rwxr-xr-x (Propriétaire: rwx, Groupe: r-x, Autres: r-x) 
    err := os.Mkdir(dirName, 0755)  
    if err != nil {  
        fmt.Println("Erreur lors de la création du répertoire :", err) 
        return  
    }  
 
    fmt.Println("Répertoire créé avec succès :", dirName)  
}

La valeur 0755 utilisée pour les permissions est un standard : elle accorde les droits complets (lecture, écriture et exécution) au propriétaire, tandis que les autres utilisateurs peuvent seulement lire et parcourir le répertoire.

b. Créer un répertoire avec des sous-dossiers

Pour créer une structure hiérarchique de dossier, os.MkdirAll est recommandé car il crée automatiquement les répertoires parents manquants. Elle ne renvoie pas d’erreur si les répertoires existent déjà.

package main  
 
import (  
   ...

Introduction aux bases de données relationnelles avec database/sql

Go propose le package standard database/sql pour interagir avec les bases de données relationnelles comme MySQL, PostgreSQL et SQLite. Ce package offre une interface générique qui fonctionne avec plusieurs moteurs de bases de données via des pilotes spécifiques.

1. Installation d’un pilote SQL

L’utilisation d’une base de données relationnelle avec Go nécessite un pilote compatible avec le moteur de base de données choisi. Le package database/sql fournit une interface standard, mais chaque moteur (MySQL, PostgreSQL, SQLite, etc.) requiert un pilote spécifique pour établir une connexion et exécuter des requêtes. Une fois le pilote téléchargé ou importé dans le code source, l’exécution de la commande go mod tidy assure la synchronisation des dépendances et la mise à jour du fichier go.mod.

a. Installer un pilote SQL pour MySQL

Le pilote github.com/go-sql-driver/mysql est nécessaire pour interagir avec MySQL.

go get -u github.com/go-sql-driver/mysql

Une fois installé, il doit être obligatoirement importé dans le projet.

import (  
    "database/sql"  
    _ "github.com/go-sql-driver/mysql"  
)

L’importation avec _ permet de charger le pilote sans l’utiliser directement dans le code.

b. Installer un pilote SQL pour PostgreSQL

PostgreSQL utilise le pilote github.com/lib/pq, qui doit être installé comme suit :

go get -u github.com/lib/pq

L’importation dans le projet se fait ainsi :

import (  
    "database/sql"  
    _ "github.com/lib/pq"  
)

c. Installer un pilote SQL pour SQLite

SQLite est un moteur de base de données léger, couramment utilisé pour des applications locales. Son pilote officiel est https://github.com/mattn/go-sqlite3. Selon le mode d’ouverture spécifié dans la chaîne de connexion, le fichier de base de données est soit utilisé s’il existe déjà, soit créé automatiquement par le système.

go get -u github.com/mattn/go-sqlite3

L’importation dans le projet :

import (  
    "database/sql"...

Utilisation d’un ORM comme GORM

GORM est un ORM (Object-Relational Mapping) populaire pour Go, qui simplifie les interactions avec les bases de données relationnelles en permettant de manipuler les données sous forme d’objets au lieu d’écrire des requêtes SQL directement.

1. Pourquoi utiliser GORM ?

GORM offre plusieurs avantages :

Simplification du code : les opérations CRUD sont facilitées.
Migration automatique : possibilité de générer et mettre à jour les tables automatiquement.
Support multi-base de données : compatible avec MySQL, PostgreSQL, SQLite et SQL Server.
Gestion des relations : support des relations One-to-One, One-to-Many, Many-to-Many.

2. Installation de GORM

L’utilisation de GORM, un ORM (Object-Relational Mapping) pour Go, simplifie la gestion des bases de données relationnelles en permettant de manipuler les données sous forme d’objets. Avant d’utiliser GORM, il est nécessaire de l’installer et de configurer un pilote compatible avec la base de données choisie.

a. Installer GORM et un pilote de base de données

Installez GORM avec la commande suivante : go get -u gorm.io/gorm, puis installez le pilote correspondant à votre base (MySQL, PostgreSQL, SQLite, SQL Server).

go get -u gorm.io/gorm

Installation des pilotes selon la base de données :

MySQL :

go get -u gorm.io/driver/mysql

PostgreSQL :

go get -u gorm.io/driver/postgres

SQLite :

go get -u gorm.io/driver/sqlite

SQL Server :

go get -u gorm.io/driver/sqlserver

Une fois les paquets installés, ils doivent être importés dans le projet.

b. Vérifier l’installation de GORM

Après l’installation, il est recommandé de vérifier que GORM fonctionne correctement en établissant une connexion simple avec la base de données.

Exemple avec MySQL :

package main  
 
import (  
    "fmt"  
    "gorm.io/driver/mysql"  
    "gorm.io/gorm"  
)  
 
func main() {  
    dsn := "user:password@tcp(localhost:3306)/testdb?charset= 
utf8mb4&parseTime=True&loc=Local"  
    db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{})  
    if...

Gestion des fichiers et des bases de données