Définir et utiliser une struct

Un struct regroupe les champs nommés en un seul type. C'est le chemin de Go de construire des « objets » – plus littéraux et immédiats que les classes, avec pas d'héritage et pas de constructeurs intégrés.

Déclaration

type Person struct {
    Name string
    Age  int
}

type introduit un nouveau type nommé. Les champs sont écrits un par ligne, name type. Des champs consécutifs du même type peuvent partager le déclaration : X, Y int.

Création

// with named fields (recommended: robust to reordering)
p := Person{Name: "Ada", Age: 36}

// positional (fragile: depends on declaration order)
q := Person{"Ada", 36}

// zero value: every field at its zero value
var r Person          // r = {Name: "", Age: 0}

// pointer: allocate with & or new
ptr := &Person{Name: "Ada"}
ptr2 := new(Person)   // *Person to a zero-value struct

Accès aux champs

p := Person{Name: "Ada", Age: 36}
fmt.Println(p.Name, p.Age)

p.Age = 37            // mutation (if p is a variable)

Sur un pointeur, ptr.Name fonctionne directement : Go effectue le déréférencement implicite. Pas de -> comme en C.

Visibilité : la règle des majuscules

Les champs avec une initiale majuscule sont exportés (visibles depuis d'autres forfaits); minuscule = privé du package actuel.

type User struct {
    Name   string  // exported
    salt   []byte  // private to the package
}

La même règle s'applique à chaque identifiant dans Go : types, fonctions, variables, champs.

Structures anonymes et imbriquées

// anonymous (handy for ad-hoc data)
config := struct {
    Host string
    Port int
}{Host: "localhost", Port: 8080}

// nested
type Address struct {
    Street string
    City   string
}
type Customer struct {
    Name    string
    Address Address
}

Comparabilité

Deux structures sont comparables avec == si TOUS leurs champs sont comparable (pas de tranches/cartes/fonctions à l'intérieur) :

a := Person{Name: "Ada", Age: 36}
b := Person{Name: "Ada", Age: 36}
fmt.Println(a == b)   // true

Cela vous permet également de les utiliser comme clés de carte.

Essayez-le

// in package other
type X struct {
    name string
}

Récapitulatif

• type Name struct { ... } : nouveau type nommé avec des champs nommés.
• Construction : T{Field: value, ...} (recommandé) ou positionnel.
• Valeur nulle : chaque champ à zéro pour son type.
• &T{...} et new(T) pour un pointeur ; déréférencement implicite (p.Field sur *T).
• Majuscule = exporté ; minuscule = privé du package.
• Les structures sont comparables à == si tous les champs le sont ; utilisables comme clés de carte.