2018-01-03 20:21 阅读 168


I have a nested structs which I need to iterate through the fields and store it in a string slice of slice. Then, output it to a csv file. Problem right now is that I am manually accessing each field in the struct and storing it in a slice of slice interface but my actual code has 100 fields so doesn't make sense to call each field manually. Also, having trouble storing slice of slice interface to csv as I get the following error when writing to a csv file where output is [][]interface{}

//      for _, value := range output {
//          err := writer.Write(value) //ERROR: can't use value (type []interface{}) as type []string in argument to writer.Write (build)
//          checkError("Failed write to file", err)
//      }: 
`can't use value (type []interface{}) as type []string in argument to writer.Write (build)`


type ApiStruct struct {
    Response []struct { //100 more fields
        A int         `json:"a"`
        B interface{} `json:"b"`
        C bool        `json:"c"`
        D string      `json:"d"`
        E int         `json:"e"`
        F float64     `json:"f"`
        G []string    `json:"g"`
        H bool        `json:"h"`
        I interface{} `json:"i"`
    } `json:"response"`

func main() {
    output := api_call()
    for _, value := range output {

    // write_file(output)


func api_call() (api_data [][]interface{}) {

    api_response := `{
    "response": [{
            "a": 2,
            "b": null,
            "c": false,
            "d": "sdasdas",
            "e": 22,
            "f": -123.2131231,
            "g": ["string1", "string2"],
            "h": true,
            "i": null
            "a": 4,
            "b": null,
            "c": true,
            "d": "sd",
            "e": 22,
            "f": 1223.2131231,
            "g": ["string3", "string4"],
            "h": true,
            "i": null

    var d ApiStruct
    err := json.Unmarshal([]byte(api_response), &d)

    if err != nil {

    //instead of manually creating the headers or row lables for CSV output, want to know if there's a way to iterate through the key values in the struct
    api_data = append(api_data, []interface{}{"A", "B", "C", "D", "E", "F", "G", "H", "I"})

    for _, v := range d.Response {
        api_data = append(api_data, []interface{}{v.A, v.B, v.C, v.D, v.E, v.F, v.G, v.H, v.I})

            I want to do a for loop on those fields and store values in an array like this or any other way that's easier to store in a csv file.
            Instead of accessing each field individually (v.A, v.B), I want to iterate through the fields because
            I have 100 fields in the struct so doesn't make sense to do v.A, etc 100 times.
            Also, I am not sure if I can range over the interface slice of slice and store it in a csv file. Think it needs to be a string slice of slice [][]string.
            Maybe need to convert interface slice of slice: [][]interface{} to string slice of slice: [][]string




Please see the link below for more details/comments in the code:


Let me know if anything is unclear! Any help is appreciated!

  • 点赞
  • 写回答
  • 关注问题
  • 收藏
  • 复制链接分享

1条回答 默认 最新

  • 已采纳
    dongtang7347 dongtang7347 2018-01-03 21:17

    You can handle the fields of a struct programmatically by using the reflect package, in particular the Type and Value types. For example:

    type Foo struct {
      A int
      B bool
      C string
      D float64
      E interface{}
    func main() {
      f := Foo{1, true, "foo", 3.45, nil}
      t := reflect.TypeOf(f)
      v := reflect.ValueOf(f)
      for i := 0; i < v.NumField(); i++ {
        fmt.Printf("OK: %q -> %#v
    ", t.Field(i).Name, v.Field(i))
      // OK: "A" -> 1
      // OK: "B" -> true
      // OK: "C" -> "foo"
      // OK: "D" -> 3.45
      // OK: "E" -> interface {}(nil)

    Using the field names and values as demonstrated above you can generate strings to use with the csv package to generate CSV:

    func (f Foo) ValueStrings() []string {
      v := reflect.ValueOf(f)
      ss := make([]string, v.NumField())
      for i := range ss {
        ss[i] = fmt.Sprintf("%v", v.Field(i))
      return ss
    func main() {
      foos := []Foo{Foo{1, true, "foo", 2.34, nil}, Foo{2, false, "bar", 3.45, 1234}}
      w := csv.NewWriter(os.Stdout)
      // Write the CSV header.
      t := reflect.TypeOf(foos[0])
      names := make([]string, t.NumField())
      for i := range names {
        names[i] = t.Field(i).Name
      if err := w.Write(names); err != nil {
      // Write the CSV rows.
      for _, foo := range foos {
        if err := w.Write(foo.ValueStrings()); err != nil {
      if err := w.Error(); err != nil {
    // A,B,C,D,E
    // 1,true,foo,2.34,<nil>
    // 2,false,bar,3.45,1234
    点赞 评论 复制链接分享