Go Academy · Les

Pointer receivers op methoden

De toestand van een struct wijzigen via pointer receivers

Les 3 van 414 stappen

Pointer receivers op methoden is een gratis Go Academy-les op CoddyKit. Dit is les 3 van 4. Je kunt 3 lessen uit dit leerpad gratis volledig lezen — daarna ontgrendelt CoddyKit PRO alle lessen, plus praktische oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Go Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Go Academy bevat in totaal 4 lessen.

Samenvatting: waarde- versus pointer-ontvanger

Een waarde-ontvanger werkt op een kopie van de struct. Een pointer-ontvanger werkt op het origineel. Gebruik pointer-ontvangers wanneer een methode de status moet wijzigen.

Wijzigen met een pointer-ontvanger

Alleen een pointer-ontvanger kan de struct wijzigen:

package main
import "fmt"

type Stack struct{ items []int }

func (s *Stack) Push(v int) { s.items = append(s.items, v) }
func (s *Stack) Pop() int {
    n := len(s.items) - 1
    v := s.items[n]
    s.items = s.items[:n]
    return v
}

func main() {
    var st Stack
    st.Push(1); st.Push(2)
    fmt.Println(st.Pop()) // 2
}

Consistentieregel

Als een methode op een type een pointer-ontvanger nodig heeft, moeten alle methodes pointer-ontvangers gebruiken. Een combinatie veroorzaakt problemen bij het voldoen aan interfaces:

package main
import "fmt"

type Counter struct{ n int }

func (c *Counter) Inc()   { c.n++ }   // pointer
func (c *Counter) Val() int { return c.n } // pointer too

func main() {
    c := &Counter{}
    c.Inc(); c.Inc()
    fmt.Println(c.Val()) // 2
}

Voldoen aan een interface

Een methode met een pointer-ontvanger staat alleen in de methodenset van *T, niet van T. Dit beïnvloedt het voldoen aan interfaces:

package main
import "fmt"

type Writer interface{ Write([]byte) }

type File struct{ name string }
func (f *File) Write(b []byte) { fmt.Println(string(b)) }

func main() {
    var w Writer = &File{"out.txt"} // OK
    // var w Writer = File{} — compile error
    w.Write([]byte("hello"))
}

Automatisch het adres nemen

Go neemt automatisch het adres wanneer je een methode met een pointer-ontvanger aanroept op een adresseerbare waarde:

package main
import "fmt"

type Box struct{ V int }
func (b *Box) Double() { b.V *= 2 }

func main() {
    b := Box{5}
    b.Double()          // Go does (&b).Double()
    fmt.Println(b.V)    // 10
}

Niet-adresseerbare waarden

Je kunt geen methodes met een pointer-ontvanger aanroepen op niet-adresseerbare waarden (elementen van maps en retourwaarden van functies die niet aan variabelen zijn toegewezen):

package main

type T struct{ V int }
func (t *T) Set(v int) { t.V = v }

func getT() T { return T{} }

func main() {
    var t T
    t.Set(1)       // OK — t is addressable
    // getT().Set(1) — ERROR: cannot take address of getT()
    _ = t
}

Ontvangers voor grote structs

Gebruik altijd pointer-ontvangers voor grote structs om dure kopieën bij elke methodeaanroep te voorkomen:

package main

type Image struct{ pixels [1024][1024]uint8 }

// Value receiver copies 1MB per call!
func (img Image) Bad() uint8 { return img.pixels[0][0] }

// Pointer receiver — zero copy
func (img *Image) Good() uint8 { return img.pixels[0][0] }

func main() { _ = Image{} }

Nil-pointer-ontvangers

Methodes met pointer-ontvangers kunnen nil netjes afhandelen:

package main
import "fmt"

type List struct{ head *node }
type node struct{ val int; next *node }

func (l *List) Len() int {
    if l == nil { return 0 }
    count := 0
    for n := l.head; n != nil; n = n.next { count++ }
    return count
}

func main() {
    var l *List
    fmt.Println(l.Len()) // 0
}

Inbedding en pointer-ontvangers

Wanneer je een type met pointer-ontvangers inbedt, moet de buitenste struct ook als pointer worden gebruikt om de overgenomen methodes te krijgen:

package main
import "fmt"

type Base struct{ V int }
func (b *Base) Set(v int) { b.V = v }

type Derived struct{ Base }

func main() {
    d := &Derived{}
    d.Set(42)           // promoted pointer-receiver method
    fmt.Println(d.V)    // 42
}

Mutexen kopiëren

Kopieer nooit een struct die een sync.Mutex bevat — gebruik altijd een pointer-ontvanger of geef de struct door via een pointer. Het kopiëren van een vergrendelde mutex veroorzaakt een deadlock:

package main
import "sync"

type Safe struct {
    mu sync.Mutex
    v  int
}

// Correct: pointer receiver
func (s *Safe) Set(v int) {
    s.mu.Lock()
    defer s.mu.Unlock()
    s.v = v
}

func main() { _ = Safe{} }

go vet detecteert fouten

Voer go vet ./... uit om veelvoorkomende fouten met pointer-ontvangers te vinden, zoals het kopiëren van mutexen en vergrendelingen. Het maakt deel uit van go build-bouwpijplijnen en CI-controles.

Korte controle

In de methodenset van welke types staat een methode met een pointer-ontvanger?

Beantwoord dit in de interactieve les

Samenvatting

Belangrijkste punten:

Pointer-ontvangers wijzigen waarden; waarde-ontvangers doen dat niet
Gebruik voor alle methodes op een type hetzelfde soort ontvanger
Alleen *T voldoet aan interfaces die methodes met pointer-ontvangers vereisen
Kopieer nooit structs met mutexen — gebruik pointer-ontvangers

Oefenopdracht

Implementeer een Queue-struct met de methodes Enqueue(int), Dequeue() (int, bool) en Len() int, allemaal met pointer-ontvangers en ondersteund door een []int-slice.

Gratis beginnen

Leer Go met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 51
Lessen: 203

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Pointer receivers op methoden” gratis?

Ja — je kunt hier op het web alle 3 lessen van het leerpad Go Academy, waaronder “Pointer receivers op methoden”, gratis volledig lezen. Daarna ontgrendelt CoddyKit PRO alle lessen, plus interactieve oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. De cursus Go Academy bevat in totaal 4 lessen.

Wat leer ik in “Pointer receivers op methoden”?

De toestand van een struct wijzigen via pointer receivers Je oefent met Go Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met Go Academy te beginnen?

Ervaring vooraf is niet nodig. Go Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 3 van 4.

Hoe lang duurt de les “Pointer receivers op methoden”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over Go Academy?

Ja. Elke les over Go Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

← Terug naar Go Academy