Comment organiser vos projets Go comme un pro

\ Quand j'ai commencé à apprendre Go, l'une des premières questions que je me suis posée était :

"Comment structurer mon code ?"

Dans des langages comme C, il est courant de tout mettre dans un seul fichier, ou peut-être de séparer les fichiers d'en-tête et d'implémentation. Mais en Go, la structure du projet est très importante : elle affecte la facilité avec laquelle vous pouvez faire évoluer, tester et partager votre code. Dans cet article, je vais expliquer pourquoi la structure est importante, comment accéder aux fonctions de différents fichiers et quelles bonnes pratiques j'apprends au fur et à mesure.

Le programme Go le plus simple

Un programme Go peut exister entièrement dans un seul fichier :

package main  import "fmt"  func main() {   fmt.Println("2 + 2 =", 2+2) } 

Cela fonctionne bien pour "hello world" ou des expériences rapides.

Mais dès que vous ajoutez plus de fonctionnalités (soustraction, multiplication, division...), le fichier devient désordonné et difficilement évolutif.

C'est là que les packages et les dossiers de Go entrent en jeu.

Introduction aux packages

En Go, chaque fichier appartient à un package.

Par convention :

• main → programme exécutable
• autres (comme calculator, utils, etc.) → logique réutilisable

Voici comment j'ai divisé le projet de calculatrice :

calculator/ │ ├── main.go └── calculator/     └── operations.go 

\

• main.go → gère l'entrée/sortie
• operations.go → définit des fonctions comme Add, Subtract, etc.

Exemple : operations.go

package calculator  func Add(a, b int) int {   return a + b }  func Subtract(a, b int) int {   return a - b }  func Multiply(a, b int) int {   return a * b }  func Divide(a, b int) (int, error) {   if b == 0 {     return 0, fmt.Errorf("cannot divide by zero")   }   return a / b, nil } 

Exemple : main.go

package main  import (   "fmt"   "GoLang-progress/calculator" )  func main() {   fmt.Println("2 + 3 =", calculator.Add(2, 3))   fmt.Println("10 - 4 =", calculator.Subtract(10, 4))   fmt.Println("6 * 7 =", calculator.Multiply(6, 7))    result, err := calculator.Divide(8, 0)   if err != nil {     fmt.Println("Error:", err)   } else {     fmt.Println("8 / 0 =", result)   } } 

Remarquez comment main.go est maintenant propre : il ne se soucie pas des mathématiques elles-mêmes, juste de la façon de les utiliser.

Accéder aux fonctions de différents fichiers

Une question fréquente des débutants :

"Comment appeler une fonction d'un autre fichier ou dossier ?"

Dans mon dépôt, je l'ai structuré comme ceci :

calculator/ │ ├── main.go └── internal/     └── calc/         └── operations.go 

Ici, les fonctions mathématiques se trouvent sous internal/calc.

operations.go (à l'intérieur de internal/calc)

\

package calc  import "fmt"  func Add(a, b int) int {   return a + b }  func Divide(a, b int) (int, error) {   if b == 0 {     return 0, fmt.Errorf("cannot divide by zero")   }   return a / b, nil } 

main.go (importation de internal/calc)

\

package main  import (   "fmt"   "github.com/turman17/GoLang-progress/calculator/internal/calc" )  func main() {   fmt.Println("2 + 3 =", calc.Add(2, 3))    result, err := calc.Divide(10, 0)   if err != nil {     fmt.Println("Error:", err)   } else {     fmt.Println("10 / 2 =", result)   } } 

Pourquoi ce chemin d'importation est nécessaire

Votre importation doit correspondre à votre chemin de module de go.mod plus le chemin du dossier.

Dans votre dépôt, go.mod contient :

module github.com/turman17/GoLang-progress 

Le code de la calculatrice que vous voulez utiliser se trouve dans le dossier :

calculator/internal/calc 

Donc le chemin d'importation complet est :

github.com/turman17/GoLang-progress/calculator/internal/calc 

Quelques notes importantes

• Nom du dossier ≠ nom du package → Le dossier est internal/calc, mais le package à l'intérieur est déclaré comme package calc.
• Les importations utilisent le chemin du module → Commencez toujours par github.com/... si c'est dans votre go.mod.
• Internal est spécial → Les packages sous /internal ne peuvent être importés que par du code à l'intérieur du même module.

Erreurs courantes et corrections

❌ import "GoLang-progress/calculator/internal/calc"

→ Organisation/nom d'utilisateur GitHub manquant. Doit utiliser le chemin complet.

❌ import "github.com/turman17/GoLang-progress/internal/calc"

→ Répertoire calculator manquant dans le chemin.

❌ go: module not found errors

→ Assurez-vous que go.mod contient module github.com/turman17/GoLang-progress et exécutez go mod tidy.

Liste de vérification rapide

• go.mod a la ligne de module correcte
• Le répertoire est calculator/internal/calc avec le package calc à l'intérieur
• main.go importe github.com/turman17/GoLang-progress/calculator/internal/calc
• Construire à partir de la racine du module :

\

go run ./calculator 

ou

go build ./calculator 

Mise à l'échelle de la structure

À mesure que les projets grandissent, vous verrez souvent ce modèle :

project-name/ │ ├── cmd/        → executables (main entrypoints) ├── internal/   → private code (not for external use) ├── pkg/        → reusable packages ├── api/        → API definitions (gRPC, OpenAPI, etc.) └── go.mod 

Pour les débutants, cela peut sembler excessif. Mais lorsque vous passez aux applications web, aux services ou aux outils MLOps, cette disposition devient essentielle.

Bonnes pratiques que j'apprends

• Gardez les packages petits et ciblés
• Utilisez des noms significatifs (calc, parser, storage)
• Ne sur-ingéniez pas — commencez simplement, refactorisez plus tard
• Évitez les dépendances circulaires (Go l'impose)

Leçons du projet Calculatrice

• Séparer la logique (operations.go) du point d'entrée (main.go) facilite les tests.
• La gestion des erreurs (comme la division par zéro) doit être explicite.
• Les chemins d'importation sont vraiment importants — surtout lors de l'utilisation de internal.

Je continuerai à partager ce que j'apprends en explorant Go pour le MLOps et le développement backend. À suivre : la gestion des erreurs et les tests en Go.

\ 👉 Consultez mon dépôt ici : https://github.com/turman17/GoLang-progress

Et restez à l'écoute pour le prochain article !