Go Academy · Leçon

Méthodes sur les structs

Récepteurs par valeur ou par pointeur

Méthodes sur les structs est une leçon Go Academy gratuite sur CoddyKit. Ceci est la leçon 2 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 méthode ?

Une méthode est une fonction avec un argument récepteur. Le récepteur se trouve entre le mot-clé func et le nom de la méthode, ce qui lie la fonction à un type.

Récepteur par valeur

Un récepteur par valeur reçoit une copie de la structure. Utilisez-le lorsque la méthode n'a pas besoin de modifier l'état :

package main
import "fmt"

type Circle struct{ Radius float64 }

func (c Circle) Area() float64 {
    return 3.14159 * c.Radius * c.Radius
}

func main() {
    c := Circle{Radius: 5}
    fmt.Printf("%.2f\n", c.Area()) // 78.54
}

Récepteur par pointeur

Un récepteur par pointeur permet à la méthode de modifier la structure. Il est plus efficace pour les grandes structures :

package main
import "fmt"

type Counter struct{ N int }

func (c *Counter) Increment() { c.N++ }
func (c *Counter) Reset()     { c.N = 0 }

func main() {
    c := Counter{}
    c.Increment(); c.Increment()
    fmt.Println(c.N) // 2
    c.Reset()
    fmt.Println(c.N) // 0
}

Quand utiliser des récepteurs pointeurs

Utilisez des récepteurs pointeurs lorsque :

La méthode doit modifier le récepteur
La structure est grande (cela évite une copie)
Par souci de cohérence : si une méthode possède un récepteur pointeur, toutes les méthodes devraient en avoir un

Utilisez des récepteurs par valeur lorsque la structure est petite et que la méthode lit uniquement les données.

Expressions et valeurs de méthodes

Les méthodes peuvent être utilisées comme des valeurs de première classe :

package main
import "fmt"

type Adder struct{ Base int }

func (a Adder) Add(n int) int { return a.Base + n }

func main() {
    a := Adder{Base: 10}
    fn := a.Add          // method value — bound to a
    fmt.Println(fn(5))   // 15
}

Méthodes sur des types autres que des structures

Vous pouvez définir des méthodes sur n'importe quel type nommé du même paquet, et pas uniquement sur des structures :

package main
import "fmt"

type Celsius float64

func (c Celsius) ToFahrenheit() float64 {
    return float64(c)*9/5 + 32
}

func main() {
    t := Celsius(100)
    fmt.Println(t.ToFahrenheit()) // 212
}

Déréférencement automatique des pointeurs

Go prend automatiquement l'adresse ou déréférence le pointeur lors de l'appel de méthodes. Vous n'avez pas besoin d'écrire manuellement (&c).Method() :

package main
import "fmt"

type Box struct{ Val int }

func (b *Box) Double() { b.Val *= 2 }

func main() {
    b := Box{Val: 5}
    b.Double()           // Go auto-takes address
    fmt.Println(b.Val)   // 10
}

Enchaîner les méthodes

Renvoyez le pointeur du récepteur pour permettre l'enchaînement des méthodes (modèle de construction) :

package main
import "fmt"

type Builder struct{ result string }

func (b *Builder) Add(s string) *Builder {
    b.result += s
    return b
}
func (b *Builder) Build() string { return b.result }

func main() {
    s := (&Builder{}).Add("Hello").Add(", ").Add("World").Build()
    fmt.Println(s)
}

Méthode chaîne (fmt.Stringer)

Implémentez la méthode String() string pour contrôler la façon dont un type est affiché :

package main
import "fmt"

type Point struct{ X, Y int }

func (p Point) String() string {
    return fmt.Sprintf("(%d, %d)", p.X, p.Y)
}

func main() {
    p := Point{3, 4}
    fmt.Println(p) // (3, 4)
}

Récepteurs pointeurs nuls

Une méthode avec un récepteur pointeur peut être appelée sur un pointeur nul, ce qui est utile pour les comportements par défaut :

package main
import "fmt"

type Node struct{ Val int }

func (n *Node) Value() int {
    if n == nil { return 0 }
    return n.Val
}

func main() {
    var n *Node
    fmt.Println(n.Value()) // 0
}

Principe de cohérence

Dans la bibliothèque standard de Go et dans le Go idiomatique, toutes les méthodes d'un type utilisent le même genre de récepteur : toutes avec un pointeur ou toutes par valeur. Mélanger les deux peut provoquer des bogues subtils avec les interfaces.

Vérification rapide

Quel type de récepteur permet à une méthode de modifier les champs d'une structure ?

Récapitulatif : méthodes

À retenir :

Les méthodes ont un récepteur entre func et leur nom
Récepteurs par valeur : lecture seule, petites structures
Récepteurs pointeurs : modification, grandes structures, cohérence
Go déréférence automatiquement — inutile d'écrire (&v).Method()
Implémentez String() string pour personnaliser l'affichage

Exercice pratique

Définissez une structure BankAccount avec un champ Balance float64. Ajoutez les méthodes à récepteur pointeur Deposit et Withdraw, ainsi qu'une méthode à récepteur par valeur String().

Questions Fréquemment Posées

La leçon « Méthodes sur les structs » est-elle gratuite ?

Oui — le texte complet de « Méthodes sur les 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 « Méthodes sur les structs » ?

Récepteurs par valeur ou par pointeur 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 2 sur 4.

Combien de temps prend la leçon « Méthodes sur les 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