Funkcje w Go (Golang): deklarowanie, wywoływanie i przekazywanie

Deklarowanie funkcji

Deklaracja funkcji to func, nazwa, parametry, typ wyniku i ciało. Typ zapisuje się po nazwie parametru, a nie przed nią.

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 przyjmuje dwie wartości int i zwraca int. greet nic nie zwraca, więc jej sygnatura nie ma typu wyniku, a ciało nie potrzebuje return.

Funkcja, która deklaruje wynik, musi kończyć się instrukcją kończącą. Jeśli jakaś ścieżka może dojść do zamykającego nawiasu klamrowego bez zwrócenia wartości, kompilator zatrzymuje się z błędem missing return.

Parametry o wspólnym typie

Kolejne parametry tego samego typu mogą dzielić jedną nazwę typu. func add(a, b int) int znaczy dokładnie to samo co func add(a int, b int) int. Można też mieszać:

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

Tutaj x i y są typu float64, a factor to int.

Wartości zwracane

Funkcja może zwrócić zero, jedną lub kilka wartości. Kilka wyników zapisuje się w nawiasach, a wywołujący odbiera je przypisaniem wielokrotnym:

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

To wypisuje 3 2. Para (value, error) to najczęstsze zastosowanie tej funkcji języka w Go i ma własną stronę o wielu wartościach zwracanych.

Argumenty są kopiowane

Go przekazuje każdy argument przez wartość. Funkcja pracuje na kopii, więc przypisanie do parametru nigdy nie zmienia zmiennej wywołującego.

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
}

Wynik:

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

Trzecia linia zaskakuje wiele osób. Wartość slice'a to mały nagłówek (wskaźnik, długość, pojemność). Kopia wskazuje na tę samą tablicę bazową, więc zapis s[0] zmienia element wywołującego. Ale append wewnątrz funkcji może zaalokować nową tablicę, a wywołujący nigdy nie zobaczy tego nowego nagłówka. Jeśli funkcja powiększa slice, zwróć nowy slice. Ta sama logika dotyczy map: funkcja może dodać klucze, które zobaczy wywołujący, bo wartość mapy odwołuje się do wspólnych danych.

Użyj parametru wskaźnikowego, gdy funkcja musi zmienić zmienną wywołującego albo gdy wartość to duża struktura, której nie chcesz kopiować przy każdym wywołaniu.

Funkcje są wartościami

Funkcja ma typ zapisywany bez nazwy: func(int, int) int. Funkcję możesz zapisać w zmiennej, umieścić w mapie lub slice'ie i przekazać do innej funkcji.

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 to funkcja anonimowa przypisana do zmiennej. Funkcje anonimowe mogą też czytać i zmieniać zmienne z otaczającego zakresu, co czyni z nich domknięcia.

Nazwany typ funkcyjny ułatwia czytanie sygnatur, gdy ten sam kształt pojawia się w wielu miejscach:

type Transform func(int) int

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

Wartość zerowa typu funkcyjnego to nil. Wywołanie funkcji nil kończy się panic z komunikatem invalid memory address or nil pointer dereference, więc sprawdzaj opcjonalne callbacki przed ich wywołaniem. Wartości funkcyjne można porównywać tylko z nil, nigdy ze sobą nawzajem.

Rekurencja

Funkcja może wywoływać samą siebie. Go nie ma optymalizacji wywołań ogonowych, ale stosy gorutyn rosną w miarę potrzeb, więc zwykłe głębokości rekurencji nie są problemem.

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 liczy od 0 do 5 i wymaga Go 1.22 lub nowszego.

Czego nie mają funkcje w Go

• Brak przeciążania. Dwie funkcje w jednym pakiecie nie mogą mieć tej samej nazwy, nawet z innymi parametrami.
• Brak argumentów domyślnych i nazwanych. Każdy parametr jest przekazywany przy każdym wywołaniu, w kolejności. Struktura konfiguracji daje nazwane, opcjonalne pola: NewServer(Config{Port: 8080}).
• Brak zagnieżdżonych funkcji nazwanych. W ciele funkcji możesz deklarować tylko funkcje anonimowe, zwykle przypisane do zmiennej.

Listy argumentów o zmiennej długości są obsługiwane przez funkcje wariadyczne.

Funkcje eksportowane i nieeksportowane

Funkcja, której nazwa zaczyna się wielką literą (Parse), jest eksportowana i można ją wywołać z innych pakietów. Nazwa zaczynająca się małą literą (parse) jest widoczna tylko w jej własnym pakiecie. Nie ma słów kluczowych public ani private; cała reguła to wielkość pierwszej litery.

Typowe błędy

• Oczekiwanie, że zmiana parametru dotrze do wywołującego. Przypisanie do parametru zmienia tylko kopię. Zwróć nową wartość albo przyjmij wskaźnik.
• Dopisywanie w funkcji i ignorowanie wyniku. func add(s []int) { s = append(s, 1) } nie wpływa na długość slice'a wywołującego. Napisz func add(s []int) []int i użyj s = add(s).
• Nieużyte wyniki. Go pozwala zignorować wartość zwracaną. go vet nie zgłasza porzuconego błędu, ale lintery takie jak errcheck (część golangci-lint) tak. Używaj _ = tylko wtedy, gdy ignorowanie to świadoma decyzja.