மாறுபட்ட செயல்பாடுகள்

மாறுபட்ட செயல்பாடுகள் தன்னிச்சையான எண்ணிக்கையிலான வாதங்களை ஏற்றுக்கொள்கின்றன அதே வகை. கடைசி வகைக்கு முன் ... ஐ வைத்து அவற்றை அறிவிக்கிறீர்கள் அளவுரு. செயல்பாட்டின் உள்ளே அளவுரு ஒரு ஸ்லைஸ் ஆகும்.

பிரகடனம்

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* செயல்பாடுகளும் மாறுபட்டவை.
• கடைசி அளவுரு மட்டுமே மாறுபட்டதாக இருக்கும்.