在Go语言中有函数重载的替代方法吗？

huangapple
go评论121阅读模式
英文:

Alternative for function overloading in Go?

问题

在Golang中是否有可能像C#中的函数重载或可选参数一样工作？或者是否有其他替代方法？

英文:

Is it possible to work similar way like the function overloading or optional parameter in C# using Golang? Or maybe an alternative way?

答案1

得分: 13

在Go语言中，对于可选参数的惯用解决方案是使用包装函数：

  1. func do(a, b, c int) {
  2.     // ...
  3. }
  5. func doSimply(a, b) {
  6.     do(a, b, 42)
  7. }

故意不包含函数重载，因为它会使代码变得难以阅读。

英文:

The idiomatic answer to optional parameters in Go is wrapper functions:

  1. func do(a, b, c int) {
  2.     // ...
  3. }
  5. func doSimply(a, b) {
  6.     do(a, b, 42)
  7. }

Function overloading was intentionally left out, because it makes code hard(er) to read.

答案2

得分: 10

不支持函数重载和可选参数。您可以通过构建自己的参数结构来解决这个问题。我的意思是像这样（未经测试，可能不起作用...）编辑：现在已经测试过了...

  1. package main
  3. import "fmt"
  5. func main() {
  6.     args := NewMyArgs("a", "b") // 默认情况下，文件名为"c"
  7.     args.SetFileName("k")
  9.     ret := Compresser(args)
  10.     fmt.Println(ret)
  11. }
  13. func Compresser(args *MyArgs) string {
  14.     return args.dstFilePath + args.srcFilePath + args.fileName
  15. }
  17. // 一个带有参数的结构体
  18. type MyArgs struct {
  19.     dstFilePath, srcFilePath, fileName string
  20. }
  22. // 一个“构造函数”函数，为args提供默认值
  23. func NewMyArgs(dstFilePath string, srcFilePath string) *MyArgs {
  24.     return &MyArgs{
  25.         dstFilePath: dstFilePath,
  26.         srcFilePath: srcFilePath,
  27.         fileName:    "c",
  28.     }
  29. }
  31. func (a *MyArgs) SetFileName(value string) {
  32.     a.fileName = value
  33. }
英文:

Neither function overloading nor optional arguments are directly supported. You could work around them building your own arguments struct. I mean like this (untested, may not work...) EDIT: now tested...

  1. package main
  3.     import "fmt"
  5.     func main() {
  6.         args:=NewMyArgs("a","b") // filename is by default "c"
  7.         args.SetFileName("k")
  9.         ret := Compresser(args)
  10.         fmt.Println(ret)
  11.     }
  13.     func Compresser(args *MyArgs) string {
  14.         return args.dstFilePath + args.srcFilePath + args.fileName 
  15.     }
  17.     // a struct with your arguments
  18.     type MyArgs struct 
  19.     {
  20.         dstFilePath, srcFilePath, fileName string 
  21.     }
  23.    // a "constructor" func that gives default values to args 
  24.     func NewMyArgs(dstFilePath string, srcFilePath string) *MyArgs {
  25.         return &MyArgs{
  26.               dstFilePath: dstFilePath, 
  27.               srcFilePath:srcFilePath, 
  28.               fileName :"c"}
  29.     }
  31.     func (a *MyArgs) SetFileName(value string){
  32.       a.fileName=value;
  33.     }

答案3

得分: 3

有一些提示在这里使用可变参数，例如：

  1. sm1 := Sum(1, 2, 3, 4) // = 1 + 2 + 3 + 4 = 10
  2. sm2 := Sum(1, 2) // = 1 + 2 = 3
  3. sm3 := Sum(7, 1, -2, 0, 18) // = 7 + 1 + -2 + 0 + 18 = 24
  4. sm4 := Sum() // = 0
  6. func Sum(numbers ...int) int {    
  7.     n := 0    
  8.     for _,number := range numbers {
  9.         n += number
  10.     }    
  11.     return n
  12. }

或者对于任何类型使用...interface{}：

  1. Ul("apple", 7.2, "BANANA", 5, "cHeRy")
  3. func Ul(things ...interface{}) {
  4.   fmt.Println("<ul>")    
  5.   for _,it := range things {
  6.     fmt.Printf("    <li>%v</li>\n", it)
  7.   }    
  8.   fmt.Println("</ul>")
  9. }
英文:

There are some hints here using variadic arguments, for example:

  1. sm1 := Sum(1, 2, 3, 4) // = 1 + 2 + 3 + 4 = 10
  2. sm2 := Sum(1, 2) // = 1 + 2 = 3
  3. sm3 := Sum(7, 1, -2, 0, 18) // = 7 + 1 + -2 + 0 + 18 = 24
  4. sm4 := Sum() // = 0
  6. func Sum(numbers ...int) int {    
  7.     n := 0    
  8.     for _,number := range numbers {
  9.         n += number
  10.     }    
  11.     return n
  12. }

Or ...interface{} for any types:

  1. Ul(&quot;apple&quot;, 7.2, &quot;BANANA&quot;, 5, &quot;cHeRy&quot;)
  3. func Ul(things ...interface{}) {
  4.   fmt.Println(&quot;&lt;ul&gt;&quot;)    
  5.   for _,it := range things {
  6.     fmt.Printf(&quot;    &lt;li&gt;%v&lt;/li&gt;\n&quot;, it)
  7.   }    
  8.   fmt.Println(&quot;&lt;/ul&gt;&quot;)
  9. }

答案4

得分: 0

package main

import "fmt"

type flavorA struct{}
type flavorB struct{}

var FlavorA = flavorA{}
var FlavorB = flavorB{}

type Something struct {
i int
f float64
}

func (flavor flavorA) NewSomething(i int) *Something {
return &Something{i:i, f:0.0}
}

func (flavor flavorB) NewSomething(f float64) *Something {
return &Something{i:0, f:f}
}

func main() {
fmt.Println(FlavorA.NewSomething(1), FlavorB.NewSomething(2))
}

英文:

An approach I use sometime for constructing an object using New methods having different arguments is to have a "flavor" pseudo type. You can try it on the Go Playground https://play.golang.org/p/5To5AcY-MRe

  1. package main
  3. import &quot;fmt&quot;
  5. type flavorA struct{}
  6. type flavorB struct{}
  8. var FlavorA = flavorA{}
  9. var FlavorB = flavorB{}
  11. type Something struct {
  12.     i int
  13.     f float64
  14. }
  16. func (flavor flavorA) NewSomething(i int) *Something {
  17. 	return &amp;Something{i:i, f:0.0}
  18. }
  20. func (flavor flavorB) NewSomething(f float64) *Something {
  21. 	return &amp;Something{i:0, f:f}
  22. }
  24. func main() {
  25. 	fmt.Println(FlavorA.NewSomething(1), FlavorB.NewSomething(2))
  26. }

答案5

得分: 0

当你有很多参数时，使用一个新的结构体或定义一个新的MyOptionBuilder类型来构建和存储所有参数，并构造出漂亮的默认值可能是有意义的。

这里有一个简单的例子，其中Go的类型默认值是可以的。

  1. package main
  3. import "fmt"
  5. type FancyFuncOptions struct {
  6. 	I int64
  7. 	S string
  8. 	F float64
  9. 	//...更多...
  10. }
  12. func FancyFunc(opts *FancyFuncOptions) {
  13. 	fmt.Println("%v", opts)
  14. }
  16. func main() {
  17.     // 简单的方式
  18. 	options := &FancyFuncOptions{S: "happy"}
  19. 	FancyFunc(options)

在Go中，如果选项具有复杂的逻辑，你会看到人们使用方法链。

  1. package main
  3. import "fmt"
  5. type FancyFuncOptions struct {
  6. 	I int64
  7. 	S string
  8. 	F float64
  9. 	//...更多...
  10. }
  12. // 链式风格
  13. func NewFancyFuncOptions() *FancyFuncOptions {
  14. 	return &FancyFuncOptions{I: 100, S: "empty", F: 0.1}
  15. }
  17. func (o *FancyFuncOptions) SetI(i int64) *FancyFuncOptions {
  18. 	o.I = i
  19. 	return o
  20. }
  22. func (o *FancyFuncOptions) SetS(s string) *FancyFuncOptions {
  23. 	o.S = s
  24. 	return o
  25. }
  27. func FancyFunc(opts *FancyFuncOptions) {
  28. 	fmt.Println("%v", opts)
  29. }
  31. func main() {
  32.     // 更加复杂
  33. 	options = NewFancyFuncOptions().SetI(234).SetS("happy")
  34. 	FancyFunc(options)

(https://go.dev/play/p/Ae_6Y6kZa97)

明白了吗？

英文:

When you have many arguments it may make sense to use a new struct for them or to define a new MyOptionBuilder type to build and store all the arguments and to construct nice defaults.

Here's a simple example where the go defaults for types are okay.

  1. package main
  3. import &quot;fmt&quot;
  5. type FancyFuncOptions struct {
  6. 	I int64
  7. 	S string
  8. 	F float64
  9. 	//...many more...
  10. }
  12. func FancyFunc(opts *FancyFuncOptions) {
  13. 	fmt.Println(&quot;%v&quot;, opts)
  14. }
  16. func main() {
  17.     // simple way
  18. 	options := &amp;FancyFuncOptions{S: &quot;happy&quot;}
  19. 	FancyFunc(options)

In golang you'll see people using method-chaining for this, if the options have complex logic.

  1. package main
  3. import &quot;fmt&quot;
  5. type FancyFuncOptions struct {
  6. 	I int64
  7. 	S string
  8. 	F float64
  9. 	//...many more...
  10. }
  12. // chaining style
  13. func NewFancyFuncOptions() *FancyFuncOptions {
  14. 	return &amp;FancyFuncOptions{I: 100, S: &quot;empty&quot;, F: 0.1}
  15. }
  17. func (o *FancyFuncOptions) SetI(i int64) *FancyFuncOptions {
  18. 	o.I = i
  19. 	return o
  20. }
  22. func (o *FancyFuncOptions) SetS(s string) *FancyFuncOptions {
  23. 	o.S = s
  24. 	return o
  25. }
  27. func FancyFunc(opts *FancyFuncOptions) {
  28. 	fmt.Println(&quot;%v&quot;, opts)
  29. }
  31. func main() {
  32.     // fancier
  33. 	options = NewFancyFuncOptions().SetI(234).SetS(&quot;happy&quot;)
  34. 	FancyFunc(options)

(https://go.dev/play/p/Ae_6Y6kZa97)

Make sense?

huangapple
  • 本文由 发表于 2012年10月23日 18:33:13
  • 转载请务必保留本文链接：https://go.coder-hub.com/13028486.html
  • go
  • overloading
匿名

发表评论

匿名网友

:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen:

确定