פונקציות variadic ב-Golang: פרמטרי ...T ופריסה עם s...

הפרמטר ...T

שימו ... לפני הטיפוס של הפרמטר האחרון. הקוראים יכולים אז להעביר כל מספר של ארגומנטים מהטיפוס הזה, כולל אף אחד. בתוך הפונקציה הפרמטר הוא slice.

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

זה מדפיס 0, 5 ו-10. בלי ארגומנטים, nums הוא slice שהוא nil באורך 0, כך שהלולאה פשוט לא רצה.

פרמטרים רגילים יכולים לבוא קודם. רק האחרון יכול להיות variadic:

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

העברת slice עם s...

אם כבר יש לכם slice, אי אפשר להעביר אותו ישירות: sum(nums) נכשל עם cannot use nums (variable of type []int) as int value in argument to sum. פרסו אותו עם ... אחרי הארגומנט:

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 היא variadic, ולכן חיבור של שני slices נכתב append(a, b...).

הפריסה חייבת להיות הדבר היחיד במקום ה-variadic. sum(1, nums...) נכשל עם too many arguments in call to sum. בנו קודם את ה-slice המשולב עם append.

ה-slice משותף, לא מועתק

כשקוראים עם ארגומנטים בודדים, Go יוצרת בשבילם slice חדש. כשפורסים slice קיים עם s..., הפונקציה מקבלת את אותו slice. כתיבה לאיברים שלו משנה את הנתונים של הקורא.

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
}

פלט:

[7 8 9]
[0 8 9]

פונקציה variadic שמשנה את הפרמטר שלה צריכה לתעד את זה, או להעתיק קודם עם slices.Clone. רוב הפונקציות ה-variadic רק קוראות את הארגומנטים שלהן, כך שזה נדיר שזה פוגע, אבל זה הבדל אמיתי משפות שבהן rest parameters הם תמיד מערך חדש.

...any ואיך fmt.Println עובדת

fmt.Println מוצהרת כ-func Println(a ...any) (n int, err error). any (כינוי ל-interface{} מאז Go 1.18) מקבל כל טיפוס, כך שאפשר להעביר מחרוזות, מספרים ו-structs בקריאה אחת.

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

העברה הלאה היא הפרט החשוב: logf מעבירה את args... ל-Printf. בלי הנקודות, Printf מקבלת ארגומנט אחד, []any, ושורת האזהרה מדפיסה [WARN] [3 8] of %!d(MISSING) workers idle. go vet מדווח missing ... in args forwarded to printf-like function רק כשפרמטר הפורמט מועבר הלאה בלי שינוי, כמו ב-fmt.Printf(format, args). כאן הפורמט נבנה עם +, כך ש-vet שותק והנקודות באחריותכם.

אי אפשר לפרוס []string לתוך ...any. טיפוסי האיברים חייבים להתאים בדיוק, אז המירו קודם:

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

דרישה של לפחות ארגומנט אחד

פרמטר variadic מקבל אפס ארגומנטים. כשהפונקציה צריכה לפחות אחד, הפכו את הראשון לפרמטר רגיל:

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

עכשיו maxOf() היא שגיאת הידור במקום בדיקה בזמן ריצה. הפונקציה המובנית max עצמה עובדת באותה צורה: היא דורשת לפחות ארגומנט אחד.

פרמטרי variadic כארגומנטים אופציונליים

ל-Go אין ערכי ברירת מחדל לפרמטרים. לפעמים משתמשים בפרמטר variadic כדי לזייף ארגומנט אופציונלי אחד:

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

זה עובד אבל נקרא גרוע, כי קוראים יכולים להעביר שלושה timeouts והחתימה לא אומרת איזה מהם מנצח. ליותר מאפשרות אחת, העדיפו struct של הגדרות, או את דפוס ה-functional options (...Option, שבו כל Option היא פונקציה שמציבה שדה). הדפוס הזה הוא variadic, אבל לכל ארגומנט יש משמעות ברורה.

תקציר הכללים