Funkcje wariadyczne w Golang: parametry ...T i rozwijanie s...

Parametr ...T

Umieść ... przed typem ostatniego parametru. Wywołujący mogą wtedy przekazać dowolną liczbę argumentów tego typu, także zero. Wewnątrz funkcji parametr jest slice'em.

package main

import "fmt"

func sum(nums ...int) int {
	total := 0
	for _, n := range nums {
		total += n
	}
	return total
}

func main() {
	fmt.Println(sum())
	fmt.Println(sum(5))
	fmt.Println(sum(1, 2, 3, 4))
}

To wypisuje 0, 5 i 10. Bez argumentów nums to slice nil o długości 0, więc pętla po prostu się nie wykonuje.

Zwykłe parametry mogą być na początku. Wariadyczny może być tylko ostatni:

func logf(level string, format string, args ...any)

Przekazywanie slice'a przez s...

Jeśli masz już slice, nie możesz przekazać go bezpośrednio: sum(nums) kończy się błędem cannot use nums (variable of type []int) as int value in argument to sum. Rozwiń go przez ... po argumencie:

package main

import "fmt"

func sum(nums ...int) int {
	total := 0
	for _, n := range nums {
		total += n
	}
	return total
}

func main() {
	nums := []int{10, 20, 30}
	fmt.Println(sum(nums...))

	more := append([]int{1, 2}, nums...)
	fmt.Println(more)
}

append też jest wariadyczne, dlatego łączenie dwóch slice'ów to append(a, b...).

Rozwinięcie musi być jedynym elementem na pozycji wariadycznej. sum(1, nums...) kończy się błędem too many arguments in call to sum. Najpierw zbuduj połączony slice przez append.

Slice jest współdzielony, a nie kopiowany

Gdy wywołujesz funkcję z pojedynczymi argumentami, Go tworzy dla nich nowy slice. Gdy rozwijasz istniejący slice przez s..., funkcja dostaje ten sam slice. Zapisy do jego elementów zmieniają dane wywołującego.

package main

import "fmt"

func zeroFirst(xs ...int) {
	if len(xs) > 0 {
		xs[0] = 0
	}
}

func main() {
	nums := []int{7, 8, 9}

	zeroFirst(nums[0], nums[1], nums[2])
	fmt.Println(nums) // untouched: a new slice was built

	zeroFirst(nums...)
	fmt.Println(nums) // changed: the same backing array
}

Wynik:

[7 8 9]
[0 8 9]

Funkcja wariadyczna, która modyfikuje swój parametr, powinna to udokumentować albo najpierw zrobić kopię przez slices.Clone. Większość funkcji wariadycznych tylko czyta argumenty, więc rzadko sprawia to kłopot, ale to realna różnica względem języków, w których parametry rest to zawsze nowa tablica.

...any i jak działa fmt.Println

fmt.Println jest zadeklarowane jako func Println(a ...any) (n int, err error). any (alias dla interface{} od Go 1.18) przyjmuje każdy typ, więc w jednym wywołaniu możesz przekazać stringi, liczby i struktury.

package main

import (
	"fmt"
	"strings"
)

func logf(level, format string, args ...any) {
	prefix := "[" + strings.ToUpper(level) + "] "
	fmt.Printf(prefix+format+"\n", args...)
}

func main() {
	logf("info", "server started on port %d", 8080)
	logf("warn", "%d of %d workers idle", 3, 8)
	logf("error", "no arguments here")
}

Ważny szczegół to przekazywanie dalej: logf przekazuje args... do Printf. Bez kropek Printf dostaje jeden argument, []any, a linia z ostrzeżeniem wypisuje [WARN] [3 8] of %!d(MISSING) workers idle. go vet zgłasza missing ... in args forwarded to printf-like function tylko wtedy, gdy parametr formatu jest przekazywany bez zmian, jak w fmt.Printf(format, args). Tutaj format jest budowany przez +, więc vet milczy i o kropki trzeba zadbać samodzielnie.

[]string nie da się rozwinąć do ...any. Typy elementów muszą się dokładnie zgadzać, więc najpierw skonwertuj:

names := []string{"a", "b"}
args := make([]any, len(names))
for i, n := range names {
	args[i] = n
}
fmt.Println(args...)

Wymaganie co najmniej jednego argumentu

Parametr wariadyczny przyjmuje zero argumentów. Gdy funkcja potrzebuje co najmniej jednego, zrób z pierwszego zwykły parametr:

package main

import "fmt"

func maxOf(first int, rest ...int) int {
	m := first
	for _, n := range rest {
		m = max(m, n)
	}
	return m
}

func main() {
	fmt.Println(maxOf(3))
	fmt.Println(maxOf(3, 9, 4))
}

Teraz maxOf() to błąd kompilacji, a nie sprawdzenie w czasie działania. Wbudowana funkcja max działa tak samo: wymaga co najmniej jednego argumentu.

Parametry wariadyczne jako argumenty opcjonalne

Go nie ma domyślnych wartości parametrów. Parametr wariadyczny bywa używany do udawania jednego opcjonalnego argumentu:

func connect(addr string, timeout ...time.Duration)

To działa, ale słabo się czyta, bo wywołujący mogą przekazać trzy timeouty, a sygnatura nie mówi, który wygrywa. Przy więcej niż jednej opcji wybierz strukturę konfiguracji albo wzorzec functional options (...Option, gdzie każde Option to funkcja ustawiająca pole). Ten wzorzec jest wariadyczny, ale każdy argument ma jasne znaczenie.

Ściągawka z zasad