JSON: eine bevölkerten Struktur in eine neue Struktur Nesting

Question

Ich habe eine Struktur wie folgt:

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

Wenn ich das in JSON Marschall, ist es sehr einfach JSON gibt, wie man es erwarten würde:

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

Ergebnis:

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

alles so weit in Ordnung!

Was ich tun möchte, bevor Sie diese Struktur in JSON Marshalling, ist Nest in einer anderen Struktur. Die resultierende Ausgabe wäre JSON, das wie folgt aussieht:

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

Wie kann ich das tun?

Answer 1

Ich glaube, Sie statisch eine andere Struktur zu verwenden, erklären könnte:

type WrappedOutput struct { 
    fields my_struct 
    meta string 
} 

Dann Sie Ihre Struktur vor Rangier

o := WrappedOutput{fields: output}

Brand new einbetten könnte so nicht sicher zu gehen, wenn dies das ist einfachste Methode es zu tun

Answer 2

Der saubere Weg, dies zu tun wäre, 2 Strukturen zu deklarieren (ich habe es global unten getan) und verschachteln My_struct in der Struktur der höheren Ebene.

Dann können Sie die höhere Ebene Struktur initialisieren, bevor es Mashalling:

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

} 

wenn Sie nicht Big_struct möchten Sie können eine anonyme Struktur innerhalb des Codes erklären, wie Sie es brauchen und Nest My_struct innen:

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

} 

Answer 3

Wenn Sie nicht über eine neue Struktur verwenden möchten, können Sie tun:

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

es ist nicht sauber, aber es macht die Arbeit.