Go Academy · leksjon

Pekermottakere på metoder

Endre struct-tilstand via pekermottakere

Leksjon 3 av 414 trinn

Pekermottakere på metoder er en gratis leksjon i Go Academy på CoddyKit. Dette er leksjon 3 av 4. Du kan lese valgfritt 3 leksjoner fra denne læringsstien gratis i sin helhet – deretter låser CoddyKit PRO opp alle leksjoner, samt praktisk øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Go Academy, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Go Academy inneholder totalt 4 leksjoner.

Oppsummering: verdi- og pekermottakere

En verdimottaker arbeider på en kopi av strukturen. En pekermottaker arbeider på originalen. Bruk pekermottakere når en metode må endre tilstanden.

Endringer med pekermottaker

Bare en pekermottaker kan endre strukturen:

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
}

Konsistensregel

Hvis en metode på en type trenger en pekermottaker, bør alle metodene bruke pekermottakere. Blanding skaper problemer med oppfyllelse av grensesnitt:

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
}

Oppfyllelse av grensesnitt

En metode med pekermottaker finnes bare i metodesettet til *T, ikke til T. Dette påvirker oppfyllelsen av grensesnitt:

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"))
}

Automatisk adressering

Go tar automatisk adressen når du kaller en metode med pekermottaker på en adresserbar verdi:

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
}

Ikke-adresserbare verdier

Du kan ikke kalle metoder med pekermottaker på ikke-adresserbare verdier (map-elementer og returverdier fra funksjoner som ikke er tilordnet variabler):

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
}

Strukturer med store mottakere

Bruk alltid pekermottakere for store strukturer for å unngå kostbare kopier ved hvert metodekall:

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{} }

Pekermottakere med nil

Metoder med pekermottakere kan håndtere nil på en kontrollert måte:

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
}

Innebygging og pekermottakere

Når du bygger inn en type med pekermottakere, må den ytre strukturen også brukes som en peker for å få de promoterte metodene:

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
}

Kopiering av mutexer

Kopier aldri en struktur som inneholder en sync.Mutex – bruk alltid en pekermottaker eller send den med peker. Kopiering av en låst mutex fører til 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 oppdager feil

Kjør go vet ./... for å oppdage vanlige feil med pekermottakere, for eksempel kopiering av mutexer og låser. Det er en del av go build-pipelines og CI-kontroller.

Hurtigsjekk

I metodesettet til hvilke typer finnes en metode med pekermottaker?

Besvar den i den interaktive leksjonen

Oppsummering

Viktig å ta med seg:

Pekermottakere gjør endringer; verdimottakere gjør det ikke
La alle metodene på en type bruke samme mottakertype
Bare *T oppfyller grensesnitt som krever metoder med pekermottakere
Kopier aldri strukturer med mutexer – bruk pekermottakere

Øvingsoppgave

Implementer en Queue-struktur med metodene Enqueue(int), Dequeue() (int, bool) og Len() int, alle med pekermottakere og støttet av en []int-slice.

Gratis å komme i gang

Lær deg Go med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs: 51
Leksjoner: 203

Start læringen gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «Pekermottakere på metoder» gratis?

Ja – du kan lese valgfritt 3 av leksjonene i læringsstien Go Academy, inkludert «Pekermottakere på metoder», gratis i sin helhet her på nettet. Deretter låser CoddyKit PRO opp alle leksjoner, samt interaktiv øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Kurset i Go Academy inneholder totalt 4 leksjoner.

Hva lærer jeg i «Pekermottakere på metoder»?

Endre struct-tilstand via pekermottakere Du øver på Go Academy med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med Go Academy?

Ingen tidligere erfaring er nødvendig. Go Academy på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 3 av 4.

Hvor lang tid tar leksjonen «Pekermottakere på metoder»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne Go Academy-leksjonen?

Ja. Alle Go Academy-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

← Tilbake til Go Academy