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 约束的类型的参数：

Golang Uber Dig

使用 uber-go/dig 在 Golang 中实现依赖注入——基于反射容器，提供 Provide/Invoke、dig.In/dig.Out 参数与结果对象，支持命名依赖等

下载

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
}