Golang Funktionen: deklarieren, aufrufen und übergeben

Eine Funktion deklarieren

Eine Funktionsdeklaration besteht aus func, einem Namen, den Parametern, dem Ergebnistyp und einem Rumpf. Der Typ steht hinter dem Parameternamen, nicht davor.

package main

import "fmt"

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

func greet(name string) {
	fmt.Println("Hello,", name)
}

func main() {
	sum := add(3, 4)
	fmt.Println(sum)
	greet("Gopher")
}

add nimmt zwei int-Werte und gibt ein int zurück. greet gibt nichts zurück, also hat seine Signatur keinen Ergebnistyp, und der Rumpf braucht kein return.

Eine Funktion, die ein Ergebnis deklariert, muss mit einer abschließenden Anweisung enden. Kann ein Pfad die schließende Klammer erreichen, ohne zurückzukehren, bricht der Compiler mit missing return ab.

Parameter mit gemeinsamem Typ

Aufeinanderfolgende Parameter desselben Typs können sich einen Typnamen teilen. func add(a, b int) int bedeutet genau dasselbe wie func add(a int, b int) int. Mischen ist auch erlaubt:

func scale(x, y float64, factor int) (float64, float64)

Hier sind x und y vom Typ float64 und factor ist ein int.

Rückgabewerte

Eine Funktion kann null, einen oder mehrere Werte zurückgeben. Mehrere Ergebnisse stehen in Klammern, und der Aufrufer empfängt sie mit einer Mehrfachzuweisung:

package main

import "fmt"

func divmod(a, b int) (int, int) {
	return a / b, a % b
}

func main() {
	q, r := divmod(17, 5)
	fmt.Println(q, r)
}

Das gibt 3 2 aus. Das Paar (value, error) ist in Go der häufigste Einsatz dieser Möglichkeit und hat eine eigene Seite zu mehreren Rückgabewerten.

Argumente werden kopiert

Go übergibt jedes Argument als Wert. Die Funktion arbeitet auf einer Kopie, eine Zuweisung an einen Parameter ändert also nie die Variable des Aufrufers.

package main

import "fmt"

type Point struct{ X, Y int }

func moveCopy(p Point) {
	p.X = 100
}

func movePtr(p *Point) {
	p.X = 100
}

func fillFirst(s []int) {
	s[0] = 99
}

func main() {
	p := Point{1, 2}
	moveCopy(p)
	fmt.Println(p) // unchanged

	movePtr(&p)
	fmt.Println(p) // changed through the pointer

	nums := []int{1, 2, 3}
	fillFirst(nums)
	fmt.Println(nums) // the slice header was copied, the elements were not
}

Die Ausgabe ist:

{1 2}
{100 2}
[99 2 3]

Die dritte Zeile überrascht viele. Ein Slice-Wert ist ein kleiner Header (Pointer, Länge, Kapazität). Die Kopie zeigt auf dasselbe Backing-Array, also schreibt s[0] in das Element des Aufrufers. Aber append in der Funktion kann ein neues Array anlegen, und den neuen Header sieht der Aufrufer nie. Wenn eine Funktion einen Slice wachsen lässt, gib den neuen Slice zurück. Dieselbe Logik gilt für Maps: Die Funktion kann Schlüssel hinzufügen, die der Aufrufer sieht, weil der Map-Wert auf geteilte Daten verweist.

Nimm einen Pointer-Parameter, wenn die Funktion die Variable des Aufrufers ändern muss oder wenn der Wert ein großes Struct ist, das du nicht bei jedem Aufruf kopieren willst.

Funktionen sind Werte

Eine Funktion hat einen Typ, geschrieben ohne den Namen: func(int, int) int. Du kannst eine Funktion in einer Variablen speichern, in eine Map oder einen Slice packen und an eine andere Funktion übergeben.

package main

import (
	"fmt"
	"strings"
)

func apply(xs []int, f func(int) int) []int {
	out := make([]int, 0, len(xs))
	for _, x := range xs {
		out = append(out, f(x))
	}
	return out
}

func double(n int) int { return n * 2 }

func main() {
	fmt.Println(apply([]int{1, 2, 3}, double))

	square := func(n int) int { return n * n }
	fmt.Println(apply([]int{1, 2, 3}, square))

	ops := map[string]func(string) string{
		"upper": strings.ToUpper,
		"lower": strings.ToLower,
	}
	fmt.Println(ops["upper"]("go"), ops["lower"]("GO"))
}

square ist eine anonyme Funktion, die einer Variablen zugewiesen ist. Anonyme Funktionen können außerdem Variablen aus dem umgebenden Scope lesen und ändern, und das macht sie zu Closures.

Ein benannter Funktionstyp macht Signaturen lesbarer, wenn dieselbe Form an vielen Stellen vorkommt:

type Transform func(int) int

func apply(xs []int, f Transform) []int

Der Nullwert eines Funktionstyps ist nil. Der Aufruf einer nil-Funktion löst eine Panic mit invalid memory address or nil pointer dereference aus, also prüf optionale Callbacks vor dem Aufruf. Funktionswerte lassen sich nur mit nil vergleichen, nie miteinander.

Rekursion

Eine Funktion kann sich selbst aufrufen. Go hat keine Tail-Call-Optimierung, aber die Stacks von Goroutinen wachsen bei Bedarf, also sind gewöhnliche Rekursionstiefen kein Problem.

package main

import "fmt"

func factorial(n int) int {
	if n <= 1 {
		return 1
	}
	return n * factorial(n-1)
}

func main() {
	for i := range 6 {
		fmt.Println(i, factorial(i))
	}
}

for i := range 6 zählt von 0 bis 5 und braucht Go 1.22 oder neuer.

Was Go-Funktionen nicht haben

• Keine Überladung. Zwei Funktionen in einem Paket können sich keinen Namen teilen, auch nicht mit unterschiedlichen Parametern.
• Keine Standardwerte oder benannten Argumente. Jeder Parameter wird bei jedem Aufruf in Reihenfolge übergeben. Ein Config-Struct liefert dir benannte, optionale Felder: NewServer(Config{Port: 8080}).
• Keine verschachtelten benannten Funktionen. Innerhalb eines Funktionsrumpfs kannst du nur anonyme Funktionen deklarieren, meist einer Variablen zugewiesen.

Argumentlisten variabler Länge gibt es über variadische Funktionen.

Exportierte und nicht exportierte Funktionen

Eine Funktion, deren Name mit einem Großbuchstaben beginnt (Parse), ist exportiert und aus anderen Paketen aufrufbar. Ein kleingeschriebener Name (parse) ist nur im eigenen Paket sichtbar. Es gibt keine Schlüsselwörter public oder private; die Großschreibung ist die ganze Regel.

Häufige Fehler

• Erwarten, dass eine Parameteränderung beim Aufrufer ankommt. Eine Zuweisung an einen Parameter ändert nur die Kopie. Gib den neuen Wert zurück oder nimm einen Pointer.
• In einer Funktion anhängen und das Ergebnis ignorieren. func add(s []int) { s = append(s, 1) } wirkt sich nicht auf die Länge des Slices beim Aufrufer aus. Schreib func add(s []int) []int und nutze s = add(s).
• Ungenutzte Ergebnisse. Go erlaubt es, einen Rückgabewert zu ignorieren. go vet meldet einen verworfenen Fehler nicht, Linter wie errcheck (Teil von golangci-lint) schon. Nimm _ = nur, wenn das Ignorieren eine bewusste Entscheidung ist.