Qu'est-ce que les structs en Go ?

Question

Accepted Answer

Un **struct** est un type composite qui groupe des champs connexes — la façon qu'a Go de définir des types de données personnalisés et de modéliser des entités. Puisque Go n'a pas de classes, les structs (plus les méthodes) sont la façon de faire de la programmation de style orientée objet.

## Définir et utiliser un struct

```go
type Person struct {
    Name string     // exported (capitalized) → accessible from other packages
    Age  int
    email string    // unexported (lowercase) → package-private
}

// creating instances
p1 := Person{Name: "Ann", Age: 30}        // named fields (preferred — clear, order-independent)
p2 := Person{"Bob", 25, "bob@x.com"}       // positional (fragile — order matters)
var p3 Person                              // zero value: {"", 0, ""}

p1.Name          // access fields with dot notation
p1.Age = 31      // mutate
```

## Visibilité des champs via la capitalisation

```text
Capitalized field/type/func name → EXPORTED (public, usable outside the package)
lowercase name → unexported (private to the package)
```

Go utilise la capitalisation, pas des mots-clés, pour la visibilité — une convention distinctive.

## Méthodes sur les structs (POO en Go)

```go
// a method is a function with a RECEIVER (the struct it operates on)
func (p Person) Greet() string {           // value receiver
    return "Hi, I'm " + p.Name
}
func (p *Person) Birthday() {                // pointer receiver — can MODIFY the struct
    p.Age++
}

p1.Greet()       // "Hi, I'm Ann"
p1.Birthday()    // modifies p1 (Go auto-takes the address)
```

Les méthodes attachent un comportement aux structs via un *receiver*. Les receivers pointeurs (`*Person`) permettent aux méthodes de modifier le struct ; les receivers valeurs obtiennent une copie.

## Les structs sont des types valeur

```go
p1 := Person{Name: "Ann"}
p2 := p1            // COPIES the entire struct (independent)
p2.Name = "Bob"
fmt.Println(p1.Name)   // "Ann" — unchanged (it was a copy)

// pass a pointer to share/modify
func update(p *Person) { p.Name = "X" }
```

Attribuer ou passer un struct le **copie** (sémantique valeur) — pour partager ou modifier, utilisez un pointeur.

## Tags de struct (métadonnées)

```go
type User struct {
    Name  string `json:"name"`           // tags guide encoding/decoding
    Email string `json:"email,omitempty"`
}
```

Les tags attachent des métadonnées (utilisées par JSON, DB, les bibliothèques de validation) lues via reflection.

## Pourquoi c'est important

Les structs sont le moyen principal de modéliser des données et de construire des types personnalisés en Go — et combinés avec les méthodes, c'est la façon qu'a Go de faire de la programmation de style orientée objet (il n'a pas de classes).

Comprendre la définition des structs, la convention de visibilité basée sur la **capitalisation** (unique à Go), la **sémantique valeur** (l'attribution copie — donc utilisez des pointeurs pour partager/modifier, une erreur courante), les méthodes avec receivers valeur vs pointeur, et les tags de struct (pour le mappage JSON/DB) est fondamental pour presque tout code Go.

Les structs apparaissent partout — modèles de domaine, configuration, payloads d'API, structures de données — ce qui les rend essentiels, une connaissance de tous les jours pour travailler efficacement en Go.