गो में फ़ंक्शन ओवरलोडिंग के लिए वैकल्पिक?

Question

क्या गोलांग का उपयोग कर सी # में फंक्शन अधिभार या वैकल्पिक पैरामीटर जैसे काम करना संभव है? या शायद एक वैकल्पिक तरीका?

Answer 1

न तो फ़ंक्शन ओवरलोडिंग और न ही वैकल्पिक तर्क सीधे समर्थित हैं। आप अपने स्वयं के तर्क संरचना का निर्माण कर सकते हैं। मैं इस तरह मतलब (अपरीक्षित, काम नहीं कर सकता ...) संपादित करें: now tested...

package main 

    import "fmt" 

    func main() { 
     args:=NewMyArgs("a","b") // filename is by default "c" 
     args.SetFileName("k") 

     ret := Compresser(args) 
     fmt.Println(ret) 
    } 

    func Compresser(args *MyArgs) string { 
     return args.dstFilePath + args.srcFilePath + args.fileName 
    } 

    // a struct with your arguments 
    type MyArgs struct 
    { 
     dstFilePath, srcFilePath, fileName string 
    } 

    // a "constructor" func that gives default values to args 
    func NewMyArgs(dstFilePath string, srcFilePath string) *MyArgs { 
     return &MyArgs{ 
       dstFilePath: dstFilePath, 
       srcFilePath:srcFilePath, 
       fileName :"c"} 
    } 

    func (a *MyArgs) SetFileName(value string){ 
     a.fileName=value; 
    } 

Answer 2

जाओ में वैकल्पिक पैरामीटर को मुहावरेदार जवाब आवरण कार्यों है:

func do(a, b, c int) { 
    // ... 
} 

func doSimply(a, b) { 
    do(a, b, 42) 
} 

समारोह से अधिक भार जानबूझकर बाहर छोड़ दिया गया था, क्योंकि यह पढ़ने के लिए कोड हार्ड (एर) बनाता है।

Answer 3

वहाँ कुछ संकेत here variadic तर्कों का उपयोग उदाहरण के लिए, कर रहे हैं:

sm1 := Sum(1, 2, 3, 4) // = 1 + 2 + 3 + 4 = 10 
sm2 := Sum(1, 2) // = 1 + 2 = 3 
sm3 := Sum(7, 1, -2, 0, 18) // = 7 + 1 + -2 + 0 + 18 = 24 
sm4 := Sum() // = 0 

func Sum(numbers ...int) int {  
    n := 0  
    for _,number := range numbers { 
     n += number 
    }  
    return n 
} 

या ...interface{} किसी भी प्रकार के लिए:

Ul("apple", 7.2, "BANANA", 5, "cHeRy") 

func Ul(things ...interface{}) { 
    fmt.Println("<ul>")  
    for _,it := range things { 
    fmt.Printf(" <li>%v</li>\n", it) 
    }  
    fmt.Println("</ul>") 
}