Go 中实现函数重载
Go 语言中不存在传统意义上的函数重载,但可以通过其他方法实现类似的效果。
1. 使用 interface{} 类型
使用 interface{} 类型可以接受不同类型参数的函数。例如,以下代码定义了一个最大值函数,它可以处理任何实现了 Max 接口的类型:
package main
import "fmt"
type Max interface {
Max(b Max) Max
}
func maxInt(a, b int) Max {
if a > b {
return a
}
return b
}
func maxFloat64(a, b float64) Max {
if a > b {
return a
}
return b
}
func main() {
fmt.Println(maxInt(1, 2)) // 2
fmt.Println(maxFloat64(1.1, 2.2)) // 2.2
}
2. 使用泛型约束
Go 1.18 及更高版本支持泛型约束,使您可以指定函数参数的类型约束。例如,以下代码定义了一个最大值函数,它可以处理任何具有实现 Comparable 约束的类型的参数:
package main
import (
"fmt"
"math"
)
type Comparable interface {
CompareTo(interface{}) int
}
func Max[T Comparable](a, b T) T {
if a.CompareTo(b) > 0 {
return a
}
return b
}
func main() {
fmt.Println(Max(1, 2)) // 2
fmt.Println(Max("a", "b")) // b
fmt.Println(Max(math.MaxInt32, math.MaxInt64)) // 9223372036854775807
}
3. 使用反射
反射使您可以获取有关函数参数类型的信息。例如,以下代码定义了一个最大值函数,它可以处理任何类型的参数:
立即学习“go语言免费学习笔记(深入)”;
package main
import (
"fmt"
"reflect"
)
func Max(a, b interface{}) interface{} {
aType := reflect.TypeOf(a)
if aType.Kind() != reflect.Comparable {
panic("Arguments must be comparable")
}
if aType.Kind() == reflect.Ptr {
aType = aType.Elem()
a = reflect.ValueOf(a).Elem().Interface()
}
if bType := reflect.TypeOf(b); bType != aType {
panic("Arguments must be of the same type")
}
aVal := reflect.ValueOf(a)
bVal := reflect.ValueOf(b)
if aVal.Compare(bVal) > 0 {
return a
}
return b
}
func main() {
fmt.Println(Max(1, 2)) // 2
fmt.Println(Max("a", "b")) // b
fmt.Println(Max(math.MaxInt32, math.MaxInt64)) // 9223372036854775807
}