Création et importation de packages Go

Introduction

Dans la section précédente, vous avez terminé un programme Go de base, qui incluait les lignes de code suivantes :

package main
import "fmt"

Comment comprendre ces deux lignes de code? Comment utiliser efficacement les instructions package et import?

Dans ce lab (atelier) LabEx, vous apprendrez à créer et importer des packages en Go. Cela vous permettra d'organiser votre code en modules réutilisables, rendant vos projets Go plus faciles à maintenir et à mettre à l'échelle.

Points de connaissance :

Définition et déclaration d'un package
Compréhension des identifiants exportés (publics) et non exportés (privés)
Différentes formes d'importation de packages : importation unique, groupée, ponctuelle, avec alias et anonyme

Déclaration et définition de packages

Un package en Go est similaire aux modules en Python ou aux bibliothèques en C. C'est une collection de fichiers de code source utilisée pour organiser et réutiliser le code. Chaque fichier Go doit déclarer un package au début du fichier.

Remarque : Un programme Go doit avoir un et un seul package nommé main, qui sert de point d'entrée pour l'exécution. Sans cela, le programme ne peut générer de fichier exécutable.

Points clés :

Identifiants exportés (publics) : Les identifiants (variables, fonctions, types, etc.) qui commencent par une lettre majuscule sont accessibles depuis d'autres packages. Considérez-les comme l'interface publique de votre package.
Identifiants non exportés (privés) : Les identifiants qui commencent par une lettre minuscule ne sont accessibles qu'au sein du même package. Ce sont considérés comme des détails d'implémentation internes du package.
Cohérence du package : Tous les fichiers dans le même dossier doivent appartenir au même package. Cela garantit que le code lié reste ensemble.
Conventions de nommage des packages : Les noms de packages doivent être en minuscules, courts et descriptifs, évitant les underscores ou les lettres capitales.

Créons notre propre package personnalisé :

Créez un dossier nommé propagandist et un fichier propagandist.go à l'intérieur :
```
mkdir ~/project/propagandist
touch ~/project/propagandist/propagandist.go
```
Écrivez le code suivant dans propagandist.go :
```
package propagandist

var Shout = "I Love LabEx" // Public variable
var secret = "I love the dress" // Private variable

func Hit() string {
    return "Don't hit me, please!"
}
```
- Shout est public car il commence par une lettre majuscule. Cela signifie que vous pouvez y accéder depuis d'autres packages qui importent propagandist.
- secret est privé car il commence par une lettre minuscule. Il ne peut être utilisé qu'au sein du package propagandist.
- Hit est une fonction publique, accessible depuis d'autres packages.
Initialisez un module Go pour le package :
```
cd ~/project/propagandist
go mod init propagandist
```
Cette commande initialise un nouveau module Go dans le répertoire propagandist, ce qui aide à gérer les dépendances du package.

Importation d'un élément unique

Pour utiliser le package propagandist, créons un nouveau programme Go. Cette étape montrera comment importer et utiliser un seul package dans votre code Go.

Créez un nouveau fichier Go nommé pacExercise.go dans le dossier du projet :
```
touch ~/project/pacExercise.go
```
Initialisez un module Go pour le programme :
```
cd ~/project
go mod init pacExercise
```
Mettez à jour le fichier go.mod pour inclure la dépendance du package local. Exécutez la commande suivante dans le terminal :
```
echo "replace propagandist =>./propagandist" >> go.mod
```
Important : Cette commande ajoute une directive replace à votre fichier go.mod. C'est crucial car cela indique à Go que le package propagandist doit être obtenu à partir du répertoire local ./propagandist au lieu d'essayer de le télécharger depuis un dépôt distant. Vous devez exécuter cette commande dans votre terminal, qui ajoutera la ligne replace propagandist =>./propagandist à votre fichier go.mod. N'écrivez pas directement cette ligne dans le fichier manuellement.
Écrivez le code suivant dans pacExercise.go pour importer et utiliser le package propagandist :
```
package main

import (
    "fmt"
    "propagandist"
)

func main() {
    fmt.Println(propagandist.Shout) // Access the public variable
}
```
- Ce code importe le package fmt pour afficher la sortie et le package propagandist.
- Il accède ensuite à la variable publique Shout du package propagandist en utilisant propagandist.Shout.
Exécutez le programme :
```
go mod tidy
go run pacExercise.go
```
La commande go mod tidy garantit que votre fichier go.mod est mis à jour avec toutes les nouvelles dépendances. La commande go run pacExercise.go compile et exécute le programme.

Sortie attendue :
```
I Love LabEx
```

Importations groupées

Lorsque vous importez plusieurs packages, vous pouvez utiliser des importations groupées pour améliorer la lisibilité et l'organisation de votre code. Il s'agit d'un choix stylistique qui n'altère pas la fonctionnalité de votre code.

Modifiez pacExercise.go pour utiliser des importations groupées :
```
package main

import (
    "fmt"
    "propagandist"
)

func main() {
    fmt.Println(propagandist.Shout)
}
```
Dans le extrait de code ci-dessus, les packages fmt et propagandist sont importés dans un seul bloc import entouré de parenthèses. Cela facilite la lecture et la gestion de plusieurs importations de packages. Cela est exactement le même que l'exemple précédent et montre comment utiliser la syntaxe d'importation groupée.
Exécutez le programme pour confirmer qu'il fonctionne toujours :
```
go run pacExercise.go
```
Le programme devrait s'exécuter sans erreur et afficher le même résultat que précédemment.

Importation ponctuelle

En utilisant une importation ponctuelle (dot import), vous pouvez omettre le préfixe du nom du package lors de l'appel de ses fonctions ou variables. Cette pratique est généralement déconseillée au profit de noms de packages explicites car elle peut entraîner des conflits d'espace de noms et réduire la lisibilité. Cependant, il est bon de savoir ce qu'il s'agit.

Modifiez pacExercise.go pour utiliser une importation ponctuelle pour fmt :

package main

import. "fmt"
import "propagandist"

func main() {
    Println(propagandist.Shout) // No `fmt.` prefix needed
}

Ici, import. "fmt" signifie que vous pouvez utiliser directement les fonctions et variables du package fmt sans le préfixe fmt..
Par exemple, vous utilisez Println au lieu de fmt.Println.

Exécutez le programme :
```
go run pacExercise.go
```
Sortie attendue :
```
I Love LabEx
```

Importation avec alias

Vous pouvez attribuer un alias à un package importé pour plus de clarté ou pour éviter les conflits lorsque deux packages ont des noms similaires. Cela est utile pour rendre votre code plus lisible et gérer les collisions d'espaces de noms.

Modifiez pacExercise.go pour attribuer l'alias io au package fmt :
```
package main

import io "fmt"
import "propagandist"

func main() {
    io.Println(propagandist.Shout) // Use the alias `io` instead of `fmt`
}
```
- import io "fmt" crée l'alias io pour le package fmt.
- Maintenant, vous utilisez io.Println au lieu de fmt.Println.
Exécutez le programme :
```
go run pacExercise.go
```

Importation anonyme

Les importations anonymes sont utilisées pour importer un package pour ses effets secondaires, comme exécuter sa fonction init(), sans avoir besoin de référencer directement aucun de ses identifiants exportés. Cela est utile pour les packages qui enregistrent des pilotes (drivers) ou effectuent d'autres tâches d'initialisation.

Modifiez pacExercise.go pour inclure une importation anonyme pour le package time :
```
package main

import (
    "fmt"
    "propagandist"
    _ "time" // Anonymous import
)

func main() {
    fmt.Println(propagandist.Shout)
}
```
- import _ "time" est une importation anonyme. Le trait de soulignement _ est utilisé comme identifiant vide, indiquant au compilateur que vous importez le package pour ses effets secondaires et que vous n'y ferrez pas référence directement dans votre code.
- La fonction init() du package time sera exécutée lorsque ce programme sera lancé. Le package time n'a pas d'effets secondaires particuliers visibles ici. Cependant, de nombreux packages utilisent cette méthode pour enregistrer des pilotes de base de données ou des paramètres de configuration.
Exécutez le programme :
```
go run pacExercise.go
```
Sortie attendue :
```
I Love LabEx
```

Résumé

Dans ce laboratoire (lab), vous avez appris :

Comment créer et définir des packages personnalisés en Go, encapsulant du code réutilisable.
La différence entre les identifiants publics (exportés) et privés (non exportés) et leur impact sur l'accessibilité.
Différentes méthodes pour importer des packages, chacune ayant son cas d'utilisation :
- Importation d'un élément unique (Single - item import) : Importation d'un package à la fois.
- Importation groupée (Grouped import) : Importation de plusieurs packages dans un seul bloc pour une meilleure organisation.
- Importation ponctuelle (Dot import) : Importation d'un package et utilisation directe de ses identifiants sans le préfixe du nom du package. (À utiliser avec prudence)
- Importation avec alias (Alias import) : Renommage des packages importés pour une meilleure lisibilité ou pour éviter les conflits de noms.
- Importation anonyme (Anonymous import) : Importation d'un package uniquement pour ses effets secondaires, comme l'initialisation.
Le rôle de la fonction init() dans les packages et comment les importations anonymes peuvent déclencher son exécution.

En terminant ce laboratoire, vous êtes désormais en mesure de structurer et de gérer efficacement des projets Go en utilisant des packages. Vous pouvez créer des modules réutilisables, contrôler l'accès aux identifiants et mieux organiser votre code, ce qui conduit à des applications Go plus maintenables et évolutives.

Summary

In this lab, you learned:

How to create and define custom packages in Go, encapsulating reusable code.
The difference between public (exported) and private (unexported) identifiers and how they impact accessibility.
Various ways to import packages, each with its use case:
- Single-item import: Importing one package at a time.
- Grouped import: Importing multiple packages in a single block for better organization.
- Dot import: Importing a package and using its identifiers directly without the package name prefix. (Use with caution)
- Alias import: Renaming imported packages for better readability or to avoid naming conflicts.
- Anonymous import: Importing a package solely for its side effects, such as initialization.
The role of the init() function in packages and how anonymous imports can trigger its execution.
The detailed workings of Go's initialization process, including:
- How package-level variables are initialized before init() functions
- The guaranteed execution order of init() functions across dependent packages
- How multiple init() functions work within a package
- The complete initialization flow from dependent packages to the main function

By completing this lab, you are now equipped to structure and manage Go projects using packages effectively. You can create reusable modules, control access to identifiers, better organize your code, and understand the initialization process, leading to more maintainable and scalable Go applications.