duanmu0834
2018-01-03 20:21
浏览 209
已采纳

遍历golang中的嵌套结构并将值存储在slice字符串的slice中

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)`

Code:

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 {
        fmt.Println(value)
    }

    // 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 {
        log.Fatal(err)
    }

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

        */

    }

    return
}

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

https://play.golang.org/p/OEdi7Dfm_KL

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

  • 写回答
  • 好问题 提建议
  • 关注问题
  • 收藏
  • 邀请回答

1条回答 默认 最新

  • 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 {
        panic(err)
      }
    
      // Write the CSV rows.
      for _, foo := range foos {
        if err := w.Write(foo.ValueStrings()); err != nil {
          panic(err)
        }
      }
      w.Flush()
    
      if err := w.Error(); err != nil {
        panic(err)
      }
    }
    // A,B,C,D,E
    // 1,true,foo,2.34,<nil>
    // 2,false,bar,3.45,1234
    
    已采纳该答案
    评论
    解决 无用
    打赏 举报

相关推荐 更多相似问题