వివిధ విధులు

వేరియాడిక్ ఫంక్షన్‌లు యొక్క ఏకపక్ష ఆర్గ్యుమెంట్‌ల సంఖ్యను అంగీకరిస్తాయి అదే రకం. మీరు చివరి రకానికి ముందు ...ని ఉంచడం ద్వారా వాటిని ప్రకటిస్తారు పరామితి. ఫంక్షన్ లోపల పరామితి స్లైస్.

డిక్లరేషన్

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* ఫంక్షన్‌లు విభిన్నమైనవి.
• చివరి పరామితి మాత్రమే వైవిధ్యంగా ఉంటుంది.