פונקציות וריאדיות

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

הַצהָרָה

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

sum()              // 0   (nums = []int{})
sum(1)             // 1
sum(1, 2, 3, 4)    // 10

רק הפרמטר האחרון יכול להיות וריאדי:

func log(prefix string, values ...any) { ... }   // ok
// func wrong(...int, suffix string) {}            // ERRORE

מורחים פרוסה

אם כבר יש לך פרוסה, אתה יכול להעביר אותו לפונקציה וריאדית עם ...:

nums := []int{1, 2, 3}
sum(nums...)         // 6 — espande lo slice nei singoli argomenti

ה"..." הולך אחרי הפרוסה. בלי ממרח תקבל סוג שגיאה: היית מעביר []int שבו הפונקציה מצפה לרצף מתוך int.

nums הוא פרוסה, לא מיכל חדש

בתוך הפונקציה nums יש סוג []int. הכל פרוסה סטנדרטית פעולות פעולות: len(nums), nums[0], range וכו'.

מקרה שימוש קלאסי: fmt.Println

כל הפונקציות Print* של fmt הן שונות:

// signature (semplificata):
// func Println(a ...any) (n int, err error)

fmt.Println("ciao", 42, true)
args := []any{"a", "b", "c"}
fmt.Println(args...)

נסה את זה

func f(args ...string) {
    _ = args
}

לְסַכֵּם

• ...T כפרמטר LAST = פונקציה וריאדית; בפנים זה []T.
• נקרא עם ערכים בודדים: המהדר אוסף אותם לפרוסה.
• נקרא עם פרוסה קיימת: slice... (מורחים, עושה שימוש חוזר בפרוסה).
• כל הפונקציות fmt.Print* הן וריאדיות.
• רק הפרמטר האחרון יכול להיות וריאדי.