Go Struct in JSON: Vollständiger Leitfaden mit Beispielen für Anfänger

Wie man Go Struct in JSON umwandelt: Vom Anfänger zum Profi

Die Arbeit mit JSON ist das tägliche Brot für jeden Backend-Entwickler in Go. Fast täglich müssen Sie Daten an den Client senden, API-Anfragen entgegennehmen oder Konfigurationen speichern. Und in 90% der Fälle ist es JSON. Aber wie verwandelt man seine eigene struct gekonnt in lesbares JSON? Es scheint so einfach zu sein? Doch der Teufel steckt im Detail: falsche Tags, leere Felder, vergessene Fehler – und schon gibt Ihre API nicht das zurück, was sie soll.

In diesem Artikel behandeln wir die Umwandlung von Go Struct in JSON von den Grundlagen bis zu fortgeschrittenen Techniken. Sie erfahren, wie Tags funktionieren, wie man leere Felder ausblendet, wie man verschachtelte Strukturen serialisiert und wie man bei Fehlern nicht auf die Nase fällt. Los geht's!

Grundlagen: Das Paket encoding/json

In der Standardbibliothek von Go gibt es das leistungsstarke Paket encoding/json. Seine Hauptwerkzeuge sind die Funktionen json.Marshal (zum Umwandeln einer Struct in JSON) und json.Unmarshal (für den umgekehrten Prozess).

Betrachten wir ein einfaches Beispiel. Wir haben eine Benutzer-Struktur:

package main

import (    "encoding/json"    "fmt")

type User struct {    Name  string    Age   int    Email string}

func main() {    user := User{        Name:  "Alexej",        Age:   30,        Email: "alex@example.com",    }

    jsonData, err := json.Marshal(user)    if err != nil {        fmt.Println("Fehler:", err)        return    }

    fmt.Println(string(jsonData))    // Ausgabe: {"Name":"Alexej","Age":30,"Email":"alex@example.com"}}

Es funktioniert, aber es gibt einen Haken: Die Schlüssel im JSON stimmen mit den Feldnamen der Struct überein (großgeschrieben). Dies entspricht nicht den JSON-Standards (normalerweise verwendet man camelCase oder snake_case).

JSON-Tags: Kontrolle über Schlüsselnamen

Um zu steuern, wie Felder im JSON aussehen, verwendet man Struct-Tags. Dies sind spezielle Annotationen, die nach dem Feldtyp in Backticks geschrieben werden.

type User struct {    Name  string `json:"name"`    Age   int    `json:"age"`    Email string `json:"email"`}

// Die Ausgabe ist nun:// {"name":"Alexej","age":30,"email":"alex@example.com"}

Tags lösen gleich mehrere Aufgaben:

• Ändern des Feldnamens – macht die Schlüssel schön und lesbar
• Feld auslassen – mit json:"-" wird das Feld vollständig aus dem JSON ausgeschlossen
• Verwaltung leerer Felder – die Option omitempty blendet das Feld aus, wenn es einen Nullwert enthält

Praktisches Beispiel mit omitempty

type User struct {    Name    string `json:"name"`    Age     int    `json:"age,omitempty"`    Email   string `json:"email,omitempty"`    IsAdmin bool   `json:"is_admin,omitempty"`}

func main() {    user := User{Name: "Maria"}    jsonData, _ := json.Marshal(user)    fmt.Println(string(jsonData))    // Ausgabe: {"name":"Maria"}    // Age, Email und IsAdmin werden ausgelassen, da sie leer sind}

Beachten Sie: omitempty funktioniert bei Nullwerten – 0, false, leerer String, nil. Dies ist sehr praktisch für APIs, bei denen keine unnötigen Felder mitgeschleppt werden müssen.

Verschachtelte Strukturen und Slices

In realen Projekten sind Daten selten flach. Oft hat man verschachtelte Objekte oder Arrays. Go meistert dies hervorragend – das Paket json verarbeitet alle Felder rekursiv.

type Address struct {    City    string `json:"city"`    Street  string `json:"street"`    ZipCode string `json:"zip_code"`}

type Company struct {    Name    string    `json:"name"`    Address Address   `json:"address"`    Tags    []string  `json:"tags"`}

func main() {    company := Company{