Go Academy · Leçon

Packages : organiser le code Go

Déclarations de packages, imports et noms exportés

Packages : organiser le code Go est une leçon Go Academy gratuite sur CoddyKit. Ceci est la leçon 1 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Go Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Go Academy comprend 4 leçons au total.

Qu’est-ce qu’un paquet ?

Chaque fichier source Go appartient à un paquet. Le nom du paquet apparaît en haut de chaque fichier. Les paquets regroupent le code associé et contrôlent sa visibilité :

// file: math/calc.go
package math

// Exported — accessible from other packages (capital letter)
func Add(a, b int) int { return a + b }

// Unexported — package-private (lowercase)
func helper() int { return 42 }

Déclaration de paquet et chemin d’importation

Le nom du paquet (court) diffère du chemin d’importation (chemin complet du module ou du répertoire) :

// Import path: github.com/myapp/util/stringutil
// Package name: stringutil (last segment by convention)
package stringutil

func Reverse(s string) string {
    r := []rune(s)
    for i, j := 0, len(r)-1; i < j; i, j = i+1, j-1 {
        r[i], r[j] = r[j], r[i]
    }
    return string(r)
}

Importer des paquets

Utilisez import pour intégrer d’autres paquets. Go exige que toutes les importations soient utilisées :

package main

import (
    "fmt"                         // standard library
    "strings"                     // standard library
    "github.com/myapp/util/math"  // third-party or local
)

func main() {
    fmt.Println(strings.ToUpper("hello"))
    fmt.Println(math.Add(1, 2))
}

Identifiants exportés et non exportés

Les identifiants commençant par une lettre majuscule sont exportés (publics). Ceux commençant par une minuscule sont non exportés (privés au paquet) :

package server

// Exported: accessible from other packages
type Server struct {
    Addr    string   // exported field
    timeout int      // unexported field
}

// Exported method
func (s *Server) Start() error { return nil }

// Unexported helper
func (s *Server) listen() {}

Paquet main et fonction main

Le paquet main est particulier : il définit un exécutable. La fonction main est le point d’entrée :

package main

import "fmt"

func main() {
    fmt.Println("Hello, Go!")
    // Program starts here and ends here
}

// All other packages are libraries — no main() needed

Fonction init()

Chaque paquet peut contenir une ou plusieurs fonctions init(), qui s’exécutent automatiquement avant main(), dans l’ordre de leur déclaration :

package config

import "fmt"

var DB string

func init() {
    DB = "localhost:5432/mydb"
    fmt.Println("config package initialized")
}

// init runs once when the package is first imported
// Multiple init() functions per file/package are allowed

Importation vide pour les effets secondaires

Importez un paquet uniquement pour les effets secondaires de sa fonction init(), en utilisant l’identifiant vide :

package main

import (
    "database/sql"
    _ "github.com/lib/pq"  // registers PostgreSQL driver via init()
)

func main() {
    db, err := sql.Open("postgres", "host=localhost dbname=test")
    _ = db
    _ = err
}

Importations avec alias

Renommez un paquet lors de son importation pour éviter les collisions de noms ou par souci de concision :

package main

import (
    "fmt"
    gomath "math"              // alias to avoid collision
    mymath "github.com/me/math"
)

func main() {
    fmt.Println(gomath.Sqrt(16))     // 4
    fmt.Println(mymath.Add(1, 2))    // 3
}

Conventions de nommage des paquets

Conventions de nommage des paquets Go :

Nom court, en minuscules et composé d’un seul mot : http, json, fmt
Correspondre au nom du répertoire : util/stringutil/ → paquet stringutil
Pas de traits de soulignement ni de camelCase dans les noms de paquets
Évitez les noms génériques comme util, common, helper
Le nom du paquet fait partie de l’identifiant : préférez http.Client à httplib.HTTPClient

Importations circulaires

Go n’autorise pas les importations circulaires (NOT). Le paquet A ne peut pas importer B si B importe A. Résolvez ce problème en extrayant le code partagé dans un troisième paquet :

// WRONG: A imports B, B imports A — compile error
// package a imports "myapp/b"
// package b imports "myapp/a"

// SOLUTION: extract shared types to package c
// package a imports "myapp/c"
// package b imports "myapp/c"
// No circular dependency

Vérification rapide

Qu’est-ce qui rend un identifiant exporté en Go ?

Récapitulatif : paquets

Concepts essentiels concernant les paquets :

Chaque fichier commence par package name
Majuscule = exporté (public), minuscule = non exporté (privé au paquet)
Importez avec le chemin complet et utilisez le nom court du paquet
init() s’exécute automatiquement avant main()
Importation vide _ "pkg" pour les effets secondaires uniquement
Les importations circulaires sont interdites

Questions Fréquemment Posées

La leçon « Packages : organiser le code Go » est-elle gratuite ?

Oui — le texte complet de « Packages : organiser le code Go » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Go Academy, passe à CoddyKit PRO. Le cours Go Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Packages : organiser le code Go » ?

Déclarations de packages, imports et noms exportés Tu pratiques Go Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Go Academy ?

Aucune expérience préalable n'est requise. Go Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 4.

Combien de temps prend la leçon « Packages : organiser le code Go » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Go Academy ?

Oui. Chaque leçon Go Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à Go Academy