Encoding nested JSON in Go

Question

I've had a lot of trouble finding an example of this. Most of the information on the internet is about decoding JSON.

I'd like to serialize some data into nested JSON, like for example:

{
  "item": {
      "title": "Items",
    "properties": [
      {
        "num": 1,
        "name": "Item 1"
      },
      {
        "num": 2,
        "name": "Item 2"
      }
    ]
  }
}

I know how to marshal data with a flat struct, but how do I put data into a struct that can be serialized with nesting?

http://play.golang.org/p/nDKmv1myTD

I found this tool that generates a struct from a JSON schema, but I don't understand how to get data into the sub structs.

http://mholt.github.io/json-to-go/

type Example struct {
    Item struct {
        Title string `json:"title"`
        Properties []struct {
            Num int `json:"num"`
            Name string `json:"name"`
        } `json:"properties"`
    } `json:"item"`
}

Answer 1

This tool you found is nice, but I would not use it. It makes it difficult to initialize the structs.

Init example with your snippet: ( http://play.golang.org/p/_Qw3Qp8XZh )

package main

import (
    "encoding/json"
    "fmt"
)

type Example struct {
    Item struct {
        Title      string `json:"title"`
        Properties []struct {
            Num  int    `json:"num"`
            Name string `json:"name"`
        } `json:"properties"`
    } `json:"item"`
}

func main() {
    info := &Example{
        Item: struct {
            Title      string `json:"title"`
            Properties []struct {
                Num  int    `json:"num"`
                Name string `json:"name"`
            } `json:"properties"`
        }{
            Title: "title",
            Properties: []struct {
                Num  int    `json:"num"`
                Name string `json:"name"`
            }{
                {Num: 0, Name: "name0"},
                {Num: 1, Name: "name1"},
            },
        },
    }

    b, err := json.Marshal(info)
    if err != nil {
        fmt.Println(err)
        return
    }
    fmt.Println(string(b))
}

Result (pretty printed):

{
  "item": {
    "title": "title",
    "properties": [
      {
        "num": 0,
        "name": "name0"
      },
      {
        "num": 1,
        "name": "name1"
      }
    ]
  }
}

I think it is better to use named struct vs anonymous nested ones.

Same example with named structs: http://play.golang.org/p/xm7BXxEGTC

package main

import (
    "encoding/json"
    "fmt"
)

type Example struct {
    Item Item `json:"item"`
}

type Item struct {
    Title      string     `json:"title"`
    Properties []Property `json:"properties"`
}

type Property struct {
    Num  int    `json:"num"`
    Name string `json:"name"`
}

func main() {
    info := &Example{
        Item: Item{
            Title: "title",
            Properties: []Property{
                {Num: 0, Name: "name0"},
                {Num: 1, Name: "name1"},
            },
        },
    }

    b, err := json.Marshal(info)
    if err != nil {
        fmt.Println(err)
        return
    }
    fmt.Println(string(b))
}

It is the exact same thing, but I find it more clear and easy to use.