Arbeiten mit JSON in Go: Parsen und Serialisieren von Daten

Einführung in die Arbeit mit JSON in Go

JSON (JavaScript Object Notation) ist eines der beliebtesten Formate für den Datenaustausch in modernen Webanwendungen, Mikrodiensten und APIs. Die Sprache Go (Golang) bietet eine integrierte, leistungsstarke Unterstützung für die Arbeit mit JSON über das Paket encoding/json. Dieses Paket ermöglicht es, Daten einfach zwischen Go-Strukturen und JSON-Strings sowie umgekehrt zu konvertieren.

In diesem Artikel werden wir im Detail besprechen, wie man das Parsen (Deserialisieren) und Serialisieren von JSON in Go durchführt. Sie erfahren, wie Sie mit einfachen und verschachtelten Strukturen arbeiten, Fehler behandeln und Feldnamen anpassen. Das Material wird sowohl für Anfänger als auch für erfahrene Entwickler nützlich sein, die ihr Wissen systematisieren möchten.

Grundlagen der Serialisierung (Marshal) in Go

Konvertieren einer Go-Struktur in JSON

Serialisierung ist der Prozess der Umwandlung eines Go-Objekts (z. B. einer Struktur oder eines Slices) in einen JSON-String. Hierfür wird die Funktion json.Marshal() verwendet. Betrachten wir ein einfaches Beispiel:

package main

import (    "encoding/json"    "fmt")

type User struct {    Name  string    Age   int    Email string}

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

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

    fmt.Println(string(jsonData))}

Ausgabe des Programms:

{"Name":"Ivan Petrov","Age":30,"Email":"ivan@example.com"}

Beachten Sie: Die Feldnamen im JSON stimmen mit den Feldnamen der Struktur überein. Oft ist es jedoch erforderlich, sie zu ändern, z. B. im camelCase-Stil. Dazu werden Struktur-Tags verwendet.

Verwendung von Tags zur JSON-Anpassung

Struktur-Tags ermöglichen es, festzulegen, wie ein Feld serialisiert wird. Fügen wir unserem Beispiel Tags hinzu:

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

Die Ausgabe sieht nun so aus:

{"name":"Ivan Petrov","age":30,"email":"ivan@example.com"}

Wichtige Tag-Optionen:

• json:"field_name" — legt den Feldnamen im JSON fest.
• omitempty — schließt das Feld aus dem JSON aus, wenn es einen Nullwert hat (leerer String, 0, false, nil).
• - — ignoriert das Feld bei der Serialisierung/Deserialisierung vollständig.

Serialisierung von Slices und Maps

Das Paket encoding/json funktioniert nicht nur mit Strukturen, sondern auch mit Slices, Maps und einfachen Typen hervorragend:

// Slice von Strukturenusers := []User{    {Name: "Anna", Age: 25},    {Name: "Boris", Age: 35},}jsonUsers, _ := json.Marshal(users)fmt.Println(string(jsonUsers))// Ausgabe: [{"name":"Anna","age":25},{"name":"Boris","age":35}]

// Mapdata := map[string]interface{}{    "status": "ok",    "count":  42,}jsonMap, _ := json.Marshal(data)fmt.Println(string(jsonMap))// Ausgabe: {"count":42,"status":"ok"}

JSON-Parsing (Unmarshal) in Go

Basis-Parsing in eine Struktur

Deserialisierung (Parsing) ist der umgekehrte Prozess: die Umwandlung eines JSON-Strings in ein Go-Objekt. Es wird die Funktion json.Unmarshal() verwendet. Wichtig: Die Zielstruktur muss exportiert sein (Felder mit Großbuchstaben beginnen) oder entsprechende Tags haben.

jsonString := `{"name":"Maria","age":28,"email":"maria@example.com"}`

var user Usererr := json.Unmarshal([]byte(jsonString), &user)if err != nil {    fmt.Println("Parsing-Fehler:", err)    return}

fmt.Printf("Name: %s, Alter: %d", user.Name, user.Age)// Ausgabe: Name: Maria, Alter: 28

Parsing von verschachtelten Strukturen

JSON enthält oft verschachtelte Objekte.