Arrays 在golang中转储接口数组

我有一系列这样的接口：

type Test struct {
    Name string
}

func main() {
    result := []Test{
        Test{Name: "ahmad"},
        Test{Name: "reza"},
    }
    dump(result)
}

如何转储此数组并生成如下字符串：

---

名字

艾哈迈德

雷扎

---

我想要类似但带有数组的东西

更新

我不想转储测试接口

我想转储每个接口

package main

import (
    "fmt"
    "reflect"
)

type Test struct {
    Name string
}

func main() {
    result := []Test{
        Test{Name: "ahmad"},
        Test{Name: "reza"},
    }
    dump(result)
}

func dump(datasets interface{}) {
    items := reflect.ValueOf(datasets)
    if items.Kind() == reflect.Slice {
        for i := 0; i < items.Len(); i++ {
            item := items.Index(i)
            if item.Kind() == reflect.Struct {
                s := reflect.ValueOf(item)
                t := reflect.TypeOf(item)
                for j := 0; j < s.NumField(); j++ {
                    fmt.Println(t.Field(j).Name)
                }
            }
        }
    }
}

如何将输出更改为：

Name
Name

---

您的示例可以使用更多的细节，但以下是我根据您提供的内容帮助您的最佳尝试。我假设转储的定义如下：

 func dump(items []interface{})

您特别希望在传入的任何对象上打印

Name

字段，而不是在传入的任何对象上打印所有字段

func dump(items []interface{}) {
    fmt.Println("Name")
    for i := 0; i < len(items); i++ {
          v := reflect.ValueOf(items[i])
          name := v.FieldByName("Name")
          fmt.Println(name.String())
    }
}

func转储（项[]接口{}）{
fmt.Println（“名称”）
对于i:=0；i

这里的工作示例

如果您想打印所有可以通过微小更改完成的字段。只需在其中添加另一个循环，在该循环中迭代

j

，并使用

v.Field（i）

获取其中的每个字段。根据您的需要，有很多方法可以在此级别构造代码（例如，如果您想打印FieldName1，然后是它的值，然后是FieldName2，然后是它的值等，那么您的代码看起来将与不包含标题或不在当前实例上逐个打印每个字段时的代码大不相同）。但这些都是你必须为自己担心的细节，或者在问题的更新中详细说明。这里有一些关于这个主题的好文章

此外，reflect packages文档也非常有用。

我找到了一种方法

package main

import (
    "fmt"
    "reflect"
)

type Test struct {
    Name string
}

func main() {
    result := []Test{
        Test{Name: "ahmad"},
        Test{Name: "reza"},
    }
    dump(result)
}

func dump(datasets interface{}) {
    items := reflect.ValueOf(datasets)
    if items.Kind() == reflect.Slice {
        for i := 0; i < items.Len(); i++ {
            item := items.Index(i)
            if item.Kind() == reflect.Struct {
                v := reflect.Indirect(item)
                for j := 0; j < v.NumField(); j++ {
                    fmt.Println(v.Type().Field(j).Name, v.Field(j).Interface())
                }
            }
        }
    }
}

主程序包
进口(
“fmt”
“反映”
)
类型测试结构{
名称字符串
}
func main（）{
结果：=[]测试{
测试{Name:“ahmad”}，
测试{Name:“reza”}，
}
转储（结果）
}
func转储（数据集接口{}）{
项目：=反映.ValueOf（数据集）
如果items.Kind（）==reflect.Slice{
对于i:=0；i

---

谢谢。

您有一个

测试
对象数组，您真的需要将这些项目视为某种接口吗？在您的示例中，这当然不是必需的，但这只是一个示例，因此进行一些澄清可能会有所帮助。如果这确实代表了您的代码，那么您应该100%地执行
result[i].Name
，并且根本不接触反射或接口。@evanmcdonnal测试对象仅用于示例。我不知道什么接口将传递给转储函数。请阅读有关此问题的更新说明。如果我知道什么接口将传递给dump，那是非常简单的。我对传递给函数的接口一无所知。
package main

import (
    "fmt"
    "reflect"
)

type Test struct {
    Name string
}

func main() {
    result := []Test{
        Test{Name: "ahmad"},
        Test{Name: "reza"},
    }
    dump(result)
}

func dump(datasets interface{}) {
    items := reflect.ValueOf(datasets)
    if items.Kind() == reflect.Slice {
        for i := 0; i < items.Len(); i++ {
            item := items.Index(i)
            if item.Kind() == reflect.Struct {
                v := reflect.Indirect(item)
                for j := 0; j < v.NumField(); j++ {
                    fmt.Println(v.Type().Field(j).Name, v.Field(j).Interface())
                }
            }
        }
    }
}