JSON：将填充的结构嵌套到新结构中

I have a struct like so:

type my_struct struct {
  First  string `json:"first"`
  Second string `json:"second"`
  Number int    `json:"number"`
}

When I marshal that into JSON, it outputs very simple JSON as you'd expect:

var output_json []byte
output_json, _ = json.Marshal(output)
fmt.Println(string(output_json))

Result:

{"first":"my_string","second":"another_string","number":2}

All fine so far!

What I'd like to do, before marshalling that struct into JSON, is nest it inside another struct. The resulting output would be JSON that looks like this:

{
  "fields": {
    "first": "my_string",
    "number": 2,
    "second": "another_string"
  },
  "meta": "data"
}

How can I do that?

I think you could statically declare another struct to use:

type WrappedOutput struct {
  fields my_struct
  meta string
}

Then you could embed your struct before marshalling

o := WrappedOutput{fields: output}

Brand new to go so not sure if this is the easiest way to do it

The clean way to do this would be to declare 2 structs (I've done it globally below) and nest My_struct inside the higher level struct.

Then you can initialize the higher level struct before Mashalling it:

package main

import (
    "encoding/json"
    "fmt"
)

type My_struct struct {
    First  string `json:"first"`
    Second string `json:"second"`
    Number int    `json:"number"`
}

type Big_struct struct {
    Fields My_struct
    Meta   string
}

func main() {

    output := Big_struct{
        Fields: My_struct{
            First:  "my_string",
            Second: "another_string",
            Number: 2,
        },
        Meta: "data",
    }

    output_json, err := json.Marshal(output)
    if err != nil {
        fmt.Println(err)
    }

    fmt.Println(string(output_json))

}

if you don't want Big_struct you can declare an anonymous struct within your code as you need it and nest My_struct inside:

package main

import (
        "encoding/json"
        "fmt"
)

type My_struct struct {
        First  string `json:"first"`
        Second string `json: "second"`
        Number int    `json:"number"`
}

func main() {

        output := struct {
                Fields My_struct
                Meta   string
        }{  
                Fields: My_struct{
                        First:  "my_string",
                        Second: "another_string",
                        Number: 2,
                },  
                Meta: "data",
        }   

        output_json, err := json.Marshal(output)
        if err != nil {
                fmt.Println(err)
        }   

        fmt.Println(string(output_json))

}

If you don't want to use a new structure, you can do:

data := my_struct{First: "first", Second: "2", Number: 123}
result, _ := json.Marshal(&map[string]interface{}{"fields":data,"meta":"data"})
fmt.Println(string(result))

it's not clean, but it does the work.