我有一个程序，其中许多功能在不同的结构中都是相似的，但是，我最终一次又一次地编写这些函数，尤其是因为内部处理的变量具有不同的结构。

我在这里写了一个示例代码。

In Go Playgroud

package main

import "fmt"

func (a *Match) Add(v Match) {
    a.Runs += v.Runs
    a.Points += v.Points
}

type Match struct {
    Runs   uint64
    Points uint64
}

func (a *Activity) Add(v Activity) {
    a.Walk += v.Walk
    a.Jog += v.Jog
}

type Activity struct {
    Walk uint64
    Jog  uint64
}

func GetDailyMatches() map[string]Match {
    var dailyMatches map[string]Match

    Match1, Match2 := Match{5, 10}, Match{1, 2}
    dailyMatches = make(map[string]Match)
    dailyMatches["01"] = Match1
    dailyMatches["02"] = Match2
    dailyMatches["03"] = Match1
    dailyMatches["04"] = Match2
    return dailyMatches
}

func GetDailyActivities() map[string]Activity {
    var dailyActivities map[string]Activity

    Activity1, Activity2 := Activity{5, 10}, Activity{1, 2}
    dailyActivities = make(map[string]Activity)
    dailyActivities["01"] = Activity1
    dailyActivities["02"] = Activity2
    dailyActivities["03"] = Activity1
    dailyActivities["04"] = Activity2
    return dailyActivities
}

func main() {
    fmt.Println(CalculateMatchSummary("01", "03"))
    fmt.Println(CalculateActivitySummary("02", "04"))
    fmt.Println(CalculateMatchSummary("01", "03"))
    fmt.Println(CalculateActivitySummary("02", "04"))
}

func CalculateMatchSummary(start, end string) (total Match) {
    dailyMatches := GetDailyMatches()
    for day, value := range dailyMatches {
        if day < start {
            continue
        } else if day > end {
            continue
        } else {
            total.Add(value)
        }
    }
    return
}

func CalculateActivitySummary(start, end string) (total Activity) {
    dailyActivities := GetDailyActivities()
    for day, value := range dailyActivities {
        if day < start {
            continue
        } else if day > end {
            continue
        } else {
            total.Add(value)
        }
    }
    return
}

如果您注意到，Match 和Activity 具有相同的功能和相同的结构，只是它们在内部具有不同的结构。

有没有一种简单的方法可以在 Golang 本身中使代码更通用(Go 泛型，Go 中没有？？)。

最佳答案

Go 有一个漂亮的包“reflect”。严格来说，您可以不实现通用性，但您可以获得相同行为的代码统一。 我稍微改变了你的 Playground :https://play.golang.org/p/bfqZsFOgVQ

主要部分:

func AddTwo(a, b interface{}) interface{} {
    va := reflect.ValueOf(a)
    vb := reflect.ValueOf(b)
    res := reflect.New(reflect.TypeOf(a)).Elem()
    if va.Kind() != reflect.Struct && vb.Kind() != reflect.Struct {
        return nil
    }

    na, nb := va.NumField(), vb.NumField()
    if na != nb {
        return nil
    }

    for i := 0; i < na; i++ {
        // additional verification needed here
        fa := va.Field(i).Uint()
        fb := vb.Field(i).Uint()
        fr := fa + fb
        res.Field(i).SetUint(fr)
    }

    return res.Interface()
}

我使用反射来检查给我的结构的字段。如果两者都是 uint64，我可以反射性地添加它们。如果您的结构包含许多 uint64，它可以将它们全部添加!

请注意，您必须在调用此函数后将生成的接口(interface)转换为给定结构的类型。这就是为什么这不是严格泛型的原因，因为返回类型是一个接口(interface)，而不是 Match 或 Activity。

编辑:甚至不需要返回一个新结构。您可以通过调用 .SetUint() 方法简单地更新“a”结构的字段。

关于go - 使代码更通用，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/33174148/