विविध कार्य

वैरिएडिक फ़ंक्शंस के तर्कों की एक मनमानी संख्या स्वीकार करते हैं एक ही प्रकार. आप अंतिम के प्रकार से पहले ... डालकर उन्हें घोषित करें पैरामीटर. फ़ंक्शन के अंदर पैरामीटर एक स्लाइस है।

घोषणा

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

fmt के Print* के सभी कार्य विविध हैं:

// 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 अंतिम पैरामीटर के रूप में = विविध फ़ंक्शन; इसके अंदर []T है।
• एकल मानों के साथ कॉल किया जाता है: कंपाइलर उन्हें एक स्लाइस में एकत्र करता है।
• मौजूदा स्लाइस के साथ कॉल किया जाता है: slice... (स्प्रेड, स्लाइस का पुन: उपयोग करता है)।
• सभी fmt.Print* फ़ंक्शन विविध हैं।
• केवल अंतिम पैरामीटर ही विविध हो सकता है।