如何从任何结构类型派生结构列表 - 从接口{}到可变长度切片接口{}

从现在开始，努力学习吧！本文《如何从任何结构类型派生结构列表 - 从接口{}到可变长度切片接口{}》主要讲解了等等相关知识点，我会在golang学习网中持续更新相关的系列文章，欢迎大家关注并积极留言建议。下面就先一起来看一下本篇正文内容吧，希望能帮到你！

我尝试实现一个采用（任何）结构的函数，返回这些结构的数组。 returnarrayofstory 用固定类型的结构体类型展示了这个想法。

尝试使用函数 returnarrayofx 对任何类型执行相同的操作，但反射在编译时失败。

package main

import (
    "fmt"
    "reflect"
)
type story_t struct {
    LANGUAGE string
    SPECIES  string
}

func ReturnArrayOfStory(x story_t) []story_t {
    x1 := x
    var a1 []story_t
    a1 = append(a1, x1)
    a1 = append(a1, x1)
    a1 = append(a1, x1)
    return a1
}

func ReturnArrayOfX(x interface{}) []interface{} {
    x1 := x
    v1 := reflect.ValueOf(&x1).Elem()
    a1 := []reflect.TypeOf(&x1)
    //  var a1 []x
    a1 = append(a1, x1)
    a1 = append(a1, x1)
    a1 = append(a1, x1)
    //return a1
    return a1
}

func main() {

    var as1 []story_t

    s1 := story_t{"EN", "Prince of Persia"}

    as1 = ReturnArrayOfStory(s1)
    //as1 := ReturnArrayOfX(s1)
    for i := 0; i < len(as1); i++ {
        fmt.Printf("%02d %+v\n", i, as1[i])
    }

    as2 := ReturnArrayOfX(s1)
    //as1 := ReturnArrayOfX(s1)
    for i := 0; i < len(as2); i++ {
        fmt.Printf("%02d %+v\n", i, as2[i])
    }

}

a1 := []reflect.TypeOf(&x1)
main.go:25:8: reflect.TypeOf is not a type

这是一个简化的场景。实际上，我喜欢从数据库等外部数据源读取多种结构类型。

• 如何通过 returnarrayofx 实现我的目标？
• 列表项 这可能吗？如果不是，为什么？

解决方案

您的问题有两种解决方案：

首先：如果您想使用反射返回类型的切片：

// you cannot return []interface{}, because this function will return [](type of x), and that is not []interface{}
func returnarrayofx(x interface{}) interface{} {
    x1 := x
    a1 := 
// this creates *[](typeof x)
reflect.new(reflect.sliceof(reflect.typeof(x)))
// append the first element to *[](typeof x)
// after this, a1 now points to a slice, not to a slice *
    a1 = reflect.append(a1.elem(), reflect.valueof(x1))
    a1 = reflect.append(a1, reflect.valueof(x1))
    a1 = reflect.append(a1, reflect.valueof(x1))
    //return [](typeof x)
    return a1.interface()
}

您可以将其用作：

as2 := returnarrayofx(s1)
arr:=as2.([]story_t)
for i := 0; i < len(arr); i++ {
    fmt.printf("%02d %+v\n", i, arr[i])
}

第二：您可以返回 []interface{} 而无需反射：

func returnarrayofx(x interface{}) []interface{} {
   ret:=make([]interface{},0)
   ret=append(ret,x)
   ret=append(ret,x)
   ret=append(ret,x)
}

然后需要处理数组的每个元素：

as2 := returnarrayofx(s1)
for i := 0; i < len(as2); i++ {
    fmt.printf("%02d %+v\n", i, as2[i])
    data:=as2[i].(story_t)
}

这是一个通用切片转换函数：

// convertslice copies the slice in src to the slice pointed to by pdst. 
// the concrete values in src must be assignable to the dst elements.
func convertslice(pdst interface{}, src interface{}) {
    dstv := reflect.valueof(pdst).elem()
    srcv := reflect.valueof(src)
    dstv.set(reflect.makeslice(dstv.type(), srcv.len(), srcv.len()))
    for i := 0; i < srcv.len(); i++ {
        dstv.index(i).set(reflect.valueof(srcv.index(i).interface()))
    }
}

像这样使用它：

// Convert []story_t to []interface{}

s0 := []story_t{{"EN", "Prince of Persia"}, {"EN", "Karateka"}}
var s1 []interface{}
convertSlice(&s1, s0)

// Convert []interface{} containing story_t to []story_t

var s2 []story_t
convertSlice(&s2, s1)

Run it on the playground。

今天关于《如何从任何结构类型派生结构列表 - 从接口{}到可变长度切片接口{}》的内容介绍就到此结束，如果有什么疑问或者建议，可以在golang学习网公众号下多多回复交流；文中若有不正之处，也希望回复留言以告知！