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

Question

我正在开展一个项目，我需要为所有将受支持的方法构建部分更新。每个部分更新都需要一个不同的结构，具有不同的字段和字段数量，并且不知道哪些将存在或不存在。我决定遍历每个结构字段，如果存在，则将其添加到数组中以在最后返回。我还花了一些时间对几个似乎最现实的函数进行基准测试来解决这个问题，并帮助做出决定。所有的结构字段都是指针。考虑到这一点，这些就是我编写的函数。注意：我无法为此创建一个 playground 示例，因为它不支持基准测试。我将链接完整的课程，并将解释放在上面。为每个部分更新结构创建一个映射函数，我将在其中分别检查每个字段。如果该字段不是nil，我会将值放入以 [key,value] 格式存储的二维数组中。处理完结构后，返回数组。创建一个使用泛型和反射来执行与上述相同的映射函数。

Answer 1

// 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

我预计反射功能会更慢，但不会慢 ~2.5 倍。它还似乎在每次迭代中分配了大约 2.5 倍的资源。是我在上面的代码中搞砸了什么，还是反射慢了那么多？

如果有任何建议可以使上面的代码更高效，我愿意接受所有建议。我已经使用 Go 工作了大约 3 个月，所以如果我在上面的代码中犯了任何 Golang 叛国罪，请宽容我。:)