Menu
Coddy logo textTech
COMMENCER À APPRENDRE
flag Fr iconFrançaisdown icon

Noms exportés et non exportés

Fait partie de la section Programmation Orientée Objet du Journey GO de Coddy. Leçon 4 sur 107.

En Go, la première lettre d’un nom détermine sa visibilité. Les noms commençant par une majuscule sont exportés (accessibles depuis d’autres packages). Les noms commençant par une minuscule sont non exportés (privés au package).

Noms exportés : visibles en dehors du package

type User struct {
    Name  string  // Champ exporté
    Email string  // Champ exporté
}

func CreateUser(name string) User { // Fonction exportée
    return User{Name: name}
}

Noms non exportés : visibles uniquement à l’intérieur du package

type secret struct {     // Structure non exportée
    password string      // Champ non exporté
}

func validate() bool {   // Fonction non exportée
    return true
}

Mixte : structure exportée avec certains champs non exportés

type Account struct {
    Username string    // Exporté - accessible n'importe où
    Email    string    // Exporté - accessible n'importe où
    password string    // Non exporté - uniquement à l'intérieur du package
}

Cette convention de nommage remplace les modificateurs d’accès tels que public et private présents dans d’autres langages.

// Lettre majuscule   = Exporté (public)
// Lettre minuscule = Non exporté (privé)

func SaveData() {}  // Exporté
func loadData() {}  // Non exporté

Suivre cette convention est essentiel en Go. Lorsque d’autres packages importent votre code, ils peuvent uniquement accéder aux noms qui commencent par une lettre majuscule.

challenge icon

Défi

Moyen

Corrige tous les noms dans product.go afin de respecter la convention de nommage des éléments exportés de Go. Mets en majuscule la première lettre de :

  • Le nom de la structure : product → Product
  • Tous les noms de champs : name, price, stock
  • Tous les noms de fonctions : totalValue, displayInfo
  • Toutes les références aux champs à l’intérieur des fonctions

Essayez vous-même

package main

import "fmt"

func main() {
    var name string
    var price float64
    var stock int
    fmt.Scan(&name, &price, &stock)

    p := Product{
        Name:  name,
        Price: price,
        Stock: stock,
    }

    fmt.Println(DisplayInfo(p))
    fmt.Printf("Total Value: %.2f\n", TotalValue(p))
}
quiz iconTestez-vous

Cette leçon comprend un petit quiz. Commencez la leçon pour y répondre et suivre votre progression.

Toutes les leçons de Programmation Orientée Objet

1Fondamentaux de la POO en Go

Fichiers externesEspace de travail et modules GoPackages et importsNoms exportés et non exportésIntroduction à la POO en GoStructs comme classesDéfinir des méthodes sur des structsRécepteurs pointeurs ou par valeurInitialisation des structsFonctions constructeursRécapitulatif - Calculatrice simple

4Interfaces

Introduction aux interfacesImplémentation impliciteL’interface comme contratInterface vide (any)Assertion de typeCommutation de typeComposition d’interfacesInterfaces Stringer et ErrorRécapitulatif - Calculateur de formes

7Encapsulation

Champs exportés vs non exportésEncapsulation au niveau du packageMéthodes Getter et SetterDissimulation de l’information en GoRécapitulatif – Fiches d’étudiants

10Génériques (Go 1.18+)

Introduction aux génériquesParamètres de typeContraintes de typeStructures génériquesSolution de contournement pour les méthodes génériquesRécapitulatif - Collection générique

13Design Patterns – Partie 1

Introduction aux Design PatternsPattern SingletonPattern FactoryPattern Abstract FactoryPattern ObserverPattern Strategy

16Défis finaux

Plateforme d’apprentissage en ligneSystème bancaireSystème de personnages de jeu

2Plongée approfondie dans les types et les structs

Types de base et compositesDéfinitions de types personnalisésTags de structStructs anonymesStructs imbriquésValeurs zéro et valeurs par défautRécapitulatif - Carnet de contacts

5La composition plutôt que l’héritage

Pourquoi Go n’a pas d’héritageBases de l’inclusion de structsPromotion des méthodesInclure plusieurs structsInclusion ou agrégationMasquage des méthodes inclusesRécapitulatif : hiérarchie des employés

8Gestion des erreurs et POO

L’interface errorTypes d’erreurs personnalisésEnrobage des erreurs (fmt.Errorf)Erreurs sentinelleserrors.Is() et errors.As()Panic, Defer et RecoverRécapitulatif - Analyseur de fichiers

11Bibliothèque standard et POO

io.Reader et io.Writersort.InterfaceInterface fmt.Stringerencoding/json avec des structsInterface http.HandlerRécapitulatif - Modèles d’API REST

14Modèles de conception – Partie 2

Modèle CommandeModèle AdaptateurModèle DécorateurModèle Méthode modèleModèle ÉtatModèle CompositeMiddleware comme décorateur

3Pointeurs et mémoire

Notions de base des pointeurs en GoPointeurs vers des structuresPassage par valeur ou par référenceLa fonction new()Garbage collection en GoRécapitulatif - Constructeur de listes chaînées

6Polymorphisme en Go

Polymorphisme via les interfacesDuck typing en GoRègles de satisfaction des interfacesCollections polymorphesInjection de dépendancesRécapitulatif – Processeur de paiements

9Concurrence et POO

Bases des GoroutinesCanaux et communicationCanaux tamponnés ou non tamponnésInstruction selectsync.Mutex et sync.RWMutexsync.WaitGroupConception de structures thread-safeRécapitulatif - Pool de workers

12Concepts avancés de la POO

Pattern des options fonctionnellesPattern Builder en GoChaînage de méthodesAlias de types vs définitionsBases de la réflexionVue d’ensemble de la génération de code

15Projet : gestion de bibliothèque

Vue d’ensemble et structure du projetStructures Book et UserLeçon de projetSystème d’empruntLeçon de projetRecherche avec des interfacesLeçon de projetCouche de persistance JSONLeçon de projetInterface CLI d’administrationLeçon de projetTests et intégrationLeçon de projet

Entraînez-vous par vous-même : Compilateur Go en ligne