Go Academy · Lektion

Pointers og funktioner

Passering som værdi over for passering som pointer

Lektion 2 af 413 trin

Pointers og funktioner er en gratis Go Academy-lektion på CoddyKit. Dette er lektion 2 af 4. Du kan læse alle 3 lektioner i dette læringsspor gratis i deres fulde længde — derefter låser CoddyKit PRO alle lektioner op samt praktiske øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. Den er en del af læringsforløbet i Go Academy, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Go Academy-kurset indeholder 4 lektioner i alt.

Værditilførsel

Go sender alle funktionsargumenter som værdier — der oprettes en kopi. Ændringer inde i funktionen påvirker ikke originalen:

package main
import "fmt"

func increment(n int) { n++ }

func main() {
    x := 5
    increment(x)
    fmt.Println(x) // 5 — unchanged
}

Overførsel via pointer

Overfør en pointer, så funktionen kan ændre originalen:

package main
import "fmt"

func increment(n *int) { *n++ }

func main() {
    x := 5
    increment(&x)
    fmt.Println(x) // 6
}

Returnering af pointere

Funktioner kan returnere pointere til heap-allokerede værdier. Go's escape-analyse sørger for sikkerheden:

package main
import "fmt"

func newInt(v int) *int { return &v }

func main() {
    p := newInt(42)
    fmt.Println(*p) // 42
}

Effektivitet med store structs

Hvis du overfører en stor struct via pointer, undgår du en dyr kopiering:

package main
import "fmt"

type BigData struct{ Data [1024]int }

func process(d *BigData) { d.Data[0] = 99 }

func main() {
    bd := BigData{}
    process(&bd)
    fmt.Println(bd.Data[0]) // 99
}

Pointer til grænseflade

Sjældent nødvendigt — grænseflader indeholder allerede en pointer internt. Det er næsten altid forkert at overføre *interface{}:

package main
import "fmt"

type Stringer interface{ String() string }

func print(s Stringer) { fmt.Println(s.String()) }

// Pass interface directly, NOT *Stringer
type Name string
func (n Name) String() string { return string(n) }

func main() {
    print(Name("Alice"))
}

Valgfrie parametre med pointere

Brug pointerparametre til at skelne mellem "ikke angivet" og nulværdien:

package main
import "fmt"

func greet(name *string) {
    if name == nil {
        fmt.Println("Hello, stranger")
        return
    }
    fmt.Println("Hello,", *name)
}

func main() {
    s := "Alice"
    greet(&s)
    greet(nil)
}

Ændring via slices

Slices indeholder allerede en intern pointer, så du har ofte ikke brug for *[]T. Men når append allokerer på ny, har du brug for en pointer til selve slicen:

package main
import "fmt"

func addItem(s *[]int, v int) { *s = append(*s, v) }

func main() {
    nums := []int{1, 2, 3}
    addItem(&nums, 4)
    fmt.Println(nums) // [1 2 3 4]
}

Pointeraliasering

Flere pointere til den samme variabel skaber aliasering — en ændring via én pointer er synlig via alle de andre:

package main
import "fmt"

func main() {
    x := 10
    a, b := &x, &x
    *a = 99
    fmt.Println(*b) // 99 — same memory
}

Undgå overdreven brug af pointere

Brug kun pointere, når det er nødvendigt:

Ændringer i en funktion
Store structs (>= ~64 bytes)
Nil som betydning af "fraværende"

Overdreven brug af pointere øger belastningen på GC og gør koden mindre tydelig.

Mønster med funktionspointere

Gem funktionspointere i et map til dispatch-tabeller:

package main
import "fmt"

func add(a, b int) int { return a + b }
func sub(a, b int) int { return a - b }

func main() {
    ops := map[string]func(int,int)int{
        "+": add, "-": sub,
    }
    fmt.Println(ops["+"](10, 3)) // 13
    fmt.Println(ops["-"](10, 3)) // 7
}

Hurtigt tjek

Hvordan lader du en funktion ændre en heltalsvariabel, der er defineret hos den kaldende funktion?

Besvar den i den interaktive lektion

Opsamling

Vigtigste pointer:

Go overfører efter værdi — brug pointere til ændringer
Returnér pointere fra konstruktører for heap-allokering
Slices indeholder en intern pointer, men append kan kræve *[]T
Undgå overdreven brug af pointere — foretræk værdier for små typer

Øvelsesopgave

Skriv en normalize-funktion, der tager *[]string og konverterer alle strenge til små bogstaver på stedet ved hjælp af strings.ToLower.

Gratis at komme i gang

Lær Go med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser: 51
Lektioner: 203

Start gratis Se hele kurset

Ofte stillede spørgsmål

Er lektionen “Pointers og funktioner” gratis?

Ja — alle 3 lektioner i læringssporet Go Academy, inklusive “Pointers og funktioner”, kan læses gratis i deres fulde længde her på webstedet. Derefter låser CoddyKit PRO alle lektioner op samt interaktive øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. Go Academy-kurset indeholder 4 lektioner i alt.

Hvad lærer jeg i “Pointers og funktioner”?

Passering som værdi over for passering som pointer Du øver dig i Go Academy med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på Go Academy?

Der kræves ingen tidligere erfaring. Go Academy på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 2 af 4.

Hvor lang tid tager lektionen “Pointers og funktioner”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne Go Academy-lektion?

Ja. Alle Go Academy-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

← Tilbage til Go Academy