Go Academy · Leçon

Définir et utiliser des structs

Littéraux de structs, accès aux champs et intégration

Définir et utiliser des structs 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'une structure ?

Une structure regroupe des champs associés de types différents sous un même type nommé. Il s'agit du principal mécanisme de Go pour définir des structures de données personnalisées, comparable à une classe, mais sans héritage.

Déclaration d'une structure

Définissez un type structure avec le mot-clé type :

package main
import "fmt"

type Person struct {
    Name string
    Age  int
    City string
}

func main() {
    p := Person{Name: "Alice", Age: 30, City: "London"}
    fmt.Println(p)
}

Littéraux de structure

Deux styles : avec des champs nommés (recommandé) et positionnel (dépendant de l'ordre et fragile) :

package main

type Point struct{ X, Y int }

func main() {
    p1 := Point{X: 1, Y: 2} // named — preferred
    p2 := Point{3, 4}        // positional — avoid in non-test code
    _ = p1; _ = p2
}

Accéder aux champs

Utilisez la notation avec un point pour lire et écrire les champs :

package main
import "fmt"

type Car struct{ Brand string; Speed int }

func main() {
    c := Car{Brand: "Tesla", Speed: 200}
    fmt.Println(c.Brand)  // Tesla
    c.Speed = 250
    fmt.Println(c.Speed)  // 250
}

Valeur nulle d'une structure

La valeur nulle d'une structure définit tous ses champs avec leurs valeurs nulles respectives. Vous pouvez l'utiliser en toute sécurité sans l'initialiser :

package main
import "fmt"

type Config struct{ Debug bool; Port int; Host string }

func main() {
    var cfg Config
    fmt.Println(cfg) // {false 0 }
    cfg.Port = 8080
    fmt.Println(cfg) // {false 8080 }
}

Comparer des structures

Les structures peuvent être comparées avec == si tous leurs champs sont comparables :

package main
import "fmt"

type Point struct{ X, Y int }

func main() {
    a := Point{1, 2}
    b := Point{1, 2}
    c := Point{3, 4}
    fmt.Println(a == b) // true
    fmt.Println(a == c) // false
}

Les structures sont des types valeur

L'affectation d'une structure copie tous ses champs. Les modifications apportées à la copie n'affectent pas l'originale :

package main
import "fmt"

type Rect struct{ W, H int }

func main() {
    r1 := Rect{10, 20}
    r2 := r1
    r2.W = 99
    fmt.Println(r1) // {10 20}
    fmt.Println(r2) // {99 20}
}

Structures imbriquées

Un champ de structure peut lui-même être une structure :

package main
import "fmt"

type Address struct{ City, Country string }
type Employee struct {
    Name    string
    Age     int
    Address Address
}

func main() {
    e := Employee{Name: "Bob", Age: 28, Address: Address{"Berlin", "DE"}}
    fmt.Println(e.Address.City) // Berlin
}

Champs exportés et non exportés

Les champs commençant par une majuscule sont exportés (publics). Les champs en minuscules sont non exportés (privés au paquet) :

package main

type config struct {
    host string // unexported
    Port int    // exported
}

func main() {
    c := config{host: "localhost", Port: 8080}
    _ = c
}

Étiquettes de structure

Les étiquettes de structure fournissent des métadonnées (par exemple, pour l'encodage JSON). Ce sont des littéraux de chaîne placés après le type du champ :

package main

type User struct {
    ID    int    `json:"id"`
    Name  string `json:"name"`
    Email string `json:"email,omitempty"`
}

func main() { _ = User{} }

Vérification rapide

Quelle est la valeur nulle d'un champ bool dans une structure ?

Récapitulatif : structures

À retenir :

Les structures regroupent des champs associés dans un type nommé
Utilisez des littéraux avec des champs nommés — évitez les littéraux positionnels
Les structures sont des types valeur — l'affectation crée une copie
Les champs commençant par une majuscule sont exportés
Les étiquettes de structure ajoutent des métadonnées pour les bibliothèques comme encoding/json

Exercice pratique

Définissez une structure Product avec les champs Name string, Price float64 et InStock bool. Créez deux instances, comparez-les avec ==, puis affichez le résultat.

Questions Fréquemment Posées

La leçon « Définir et utiliser des structs » est-elle gratuite ?

Oui — le texte complet de « Définir et utiliser des structs » 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 « Définir et utiliser des structs » ?

Littéraux de structs, accès aux champs et intégration 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 « Définir et utiliser des structs » ?

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