我可以优化这个 Go 反射函数，使其不那么慢吗？

大家好，今天本人给大家带来文章《我可以优化这个 Go 反射函数，使其不那么慢吗？》，文中内容主要涉及到，如果你对Golang方面的知识点感兴趣，那就请各位朋友继续看下去吧~希望能真正帮到你们，谢谢！

我正在开发一个项目，我需要为所有支持的方法构建部分更新。每个部分更新都需要不同的结构，具有不同的字段和字段数量，并且不知道哪些会存在或不存在。我决定检查每个结构字段，如果存在，则将其添加到数组中以在最后返回。我还花了一些时间对几个看起来最现实的函数进行基准测试，以解决这个问题并帮助做出决定。

所有结构字段都将是指针。考虑到这一点，这些是我编写的函数。

注意：我无法为此创建演示示例，因为它不支持基准。我将链接完整的类，并将解释放在它们上面。

1. 为每个部分更新结构创建一个映射函数，我将在其中单独检查每个字段。如果该字段不是 nil，我会将值放入以 [key,value] 格式存储的二维数组中。处理完结构体后，返回数组。
2. 创建一个使用泛型和反射执行与上述相同操作的映射函数。

// main.go
package main

import (
    "reflect"
    "strings"
    "time"
)

type updaterequest struct {
    fieldone   *string    `json:"field_one,omitempty"`
    fieldtwo   *string    `json:"field_two,omitempty"`
    fieldthree *string    `json:"field_three,omitempty"`
    fieldfour  *string    `json:"field_four,omitempty"`
    fieldfive  *string    `json:"field_five,omitempty"`
    fieldsix   *time.time `json:"field_six,omitempty" time_format:"2006-01-02"`
}

// mapping function that would need to be recreated for each partial update struct.
func manualupdaterequestmapping(req *updaterequest) [][]string {
    vals := make([][]string, 0, 6)
    if req.fieldone != nil {
        vals = append(vals, []string{"field_one", *req.fieldone})
    }

    if req.fieldtwo != nil && req.fieldthree != nil {
        vals = append(vals, []string{"field_two", *req.fieldtwo}, []string{"field_three", *req.fieldthree})
    }

    if req.fieldfour != nil {
        vals = append(vals, []string{"field_four", *req.fieldfour})
    }

    if req.fieldfive != nil {
        vals = append(vals, []string{"field_five", *req.fieldfive})
    }

    if req.fieldsix != nil {
        vals = append(vals, []string{"field_six", req.fieldsix.format(time.rfc3339)})
    }

    return vals
}

// generics and reflection function
func reflectupdaterequestmapping[t *updaterequest](str t) [][]string {
    valholder := reflect.valueof(*str)
    if valholder.kind() != reflect.struct {
        return nil
    }
    vals := make([][]string, 0, valholder.numfield())
    for i := 0; i < valholder.numfield(); i++ {
        if valholder.field(i).isnil() {
            continue
        }
        spl := strings.split(valholder.type().field(i).tag.get("json"), ",")

        if valholder.field(i).elem().type() != reflect.typeof(time.time{}) {
            vals = append(vals, []string{spl[0], valholder.field(i).elem().string()})
        } else {
            vals = append(vals, []string{spl[0], valholder.field(i).interface().(*time.time).format(time.rfc3339)})
        }
    }
    return vals
}

这是我运行的基准方法：

// main_test.go
package main

import (
    "testing"
    "time"
)

func benchmarkboth(b *testing.b) {

    field1 := "testfield1"
    field2 := "testfield2"
    field3 := "testfield3"
    field4 := "testfield4"
    field5 := "testfield5"
    date1, _ := time.parse(time.rfc3339, "2004-10-16t12:40:53.00z")

    str := &updaterequest{
        fieldone:   &field1,
        fieldtwo:   &field2,
        fieldthree: &field3,
        fieldfour:  &field4,
        fieldfive:  &field5,
        fieldsix:   &date1,
    }
    b.run("manualupdaterequestmapping", func(b *testing.b) {
        for i := 0; i < b.n; i++ {
            _ = manualupdaterequestmapping(str)
        }
    })

    b.run("reflectupdaterequestmapping", func(b *testing.b) {
        for i := 0; i < b.n; i++ {
            _ = reflectupdaterequestmapping(str)
        }
    })
}

下面是使用的cpu和测试结果：

cpu: 12th Gen Intel(R) Core(TM) i9-12900KF
BenchmarkBoth/ManualUpdateRequestMapping-24              3560083           331.9 ns/op       368 B/op          8 allocs/op
BenchmarkBoth/ReflectUpdateRequestMapping-24             1393377           866.7 ns/op       648 B/op         21 allocs/op
PASS
ok      com.example.stack   3.745s

我预计 reflection 函数会更慢，但不会慢 2.5 倍。每次迭代似乎还分配了约 2.5 倍的资源。是我在上面的代码中搞砸了一些事情，还是反射速度慢了很多？

如果有任何建议可以使上面的代码更高效，我愿意接受所有建议。我已经使用 go 工作了大约 3 个月，所以如果我在上面的代码中犯了任何 golang 叛逆行为，请对我宽容一些。 :)

正确答案

反射比非反射代码慢。这是一个改进。一些注意事项：

• 通过将字段作为常规类型值获取并从那里开始工作，减少反射调用。
• 不需要那种新奇的类型参数之类的东西。
• 说到golang叛逆，这种语言的名字就是go。

既然如此，代码如下：

func UpdateRequestMapping(p any) [][]string {
    v := reflect.ValueOf(p).Elem()
    if v.Kind() != reflect.Struct {
        return nil
    }
    t := v.Type()
    result := make([][]string, t.NumField())
    for i := 0; i < t.NumField(); i++ {
        var ok bool
        var value string
        switch f := v.Field(i).Interface().(type) {
        case *string:
            if f != nil {
                ok = true
                value = *f
            }
        case *time.Time:
            if f != nil {
                ok = true
                value = (*f).Format(time.RFC3339)
            }
        }
        if ok {
            name, _, _ := strings.Cut(t.Field(i).Tag.Get("json"), ",")
            result[i] = []string{name, value}
        }
    }
    return result
}

今天关于《我可以优化这个 Go 反射函数，使其不那么慢吗？》的内容就介绍到这里了，是不是学起来一目了然！想要了解更多关于的内容请关注golang学习网公众号！