Arbeiten mit JSON in Go: Parsing und Serialisierung in der Praxis

Arbeiten mit JSON in Go: Parsing und Serialisierung in der Praxis

JSON (JavaScript Object Notation) ist eines der beliebtesten Datenformate für den Datenaustausch in der Webentwicklung. In der Sprache Go (Golang) wird die Arbeit mit JSON über das Standardpaket encoding/json realisiert, das leistungsstarke und praktische Werkzeuge für die Serialisierung (Umwandlung von Datenstrukturen in JSON) und Deserialisierung (Parsing von JSON in Go-Strukturen) bereitstellt. In diesem Artikel werden wir anhand praktischer Beispiele detailliert betrachten, wie man mit JSON in Go arbeitet.

Grundlagen: Serialisierung von Strukturen in JSON

Die gebräuchlichste Methode, um in Go mit JSON zu arbeiten, ist die Verwendung von Strukturen mit Tags. Tags ermöglichen es, Feldnamen in JSON festzulegen, die von den Feldnamen in Go abweichen können. Betrachten wir ein grundlegendes Beispiel der Serialisierung:

package main

import (    "encoding/json"    "fmt")

type User struct {    ID       int    `json:"id"`    Name     string `json:"name"`    Email    string `json:"email"`    IsActive bool   `json:"is_active"`}

func main() {    user := User{        ID:       1,        Name:     "Ivan Petrov",        Email:    "ivan@example.com",        IsActive: true,    }

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

    fmt.Println(string(jsonData))    // Ausgabe: {"id":1,"name":"Ivan Petrov","email":"ivan@example.com","is_active":true}}

Beachten Sie: Wir verwenden Tags json:"feldname", um die Schlüsselnamen in JSON zu steuern. Dies ist besonders praktisch, wenn bestimmte Namenskonventionen eingehalten werden müssen (z.B. snake_case in JSON und CamelCase in Go).

Parsing von JSON in Go-Strukturen

Die Deserialisierung (Parsing) von JSON-Daten in Strukturen erfolgt mit der Funktion json.Unmarshal. Wichtig ist, dass die Struktur der Struktur des JSON-Objekts entspricht. Fahren wir mit unserem Beispiel fort:

func main() {    jsonString := `{"id":2,"name":"Maria Sidorova","email":"maria@example.com","is_active":false}`

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

    fmt.Printf("ID: %d, Name: %s, Email: %s, Aktiv: %t",        user.ID, user.Name, user.Email, user.IsActive)    // Ausgabe: ID: 2, Name: Maria Sidorova, Email: maria@example.com, Aktiv: false}

Wichtig: Der Funktion json.Unmarshal wird immer ein Zeiger auf die Struktur übergeben (&user), sonst werden die Änderungen nicht gespeichert.

Arbeiten mit verschachtelten Strukturen und Arrays

Reale JSON-Daten enthalten oft verschachtelte Objekte und Arrays. Go ermöglicht es, solche Fälle elegant mit verschachtelten Strukturen zu behandeln:

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

type Employee struct {    ID      int      `json:"id"`    Name    string   `json:"name"`    Skills  []string `json:"skills"`    Address Address  `json:"address"`}

func main() {    jsonData := `{        "id": 101,        "name": "Alexei Ivanov",        "skills": ["Go", "Python", "Docker"],        "address": {            "city": "Moskau",            "street": "Twerskaja, 10",            "zip_code": "101000"        }    }`

    var emp Employee    err := json.Unmarshal([]byte(jsonData), &emp)    if err != nil {        fmt.Println("Fehler:", err)        return    }

    fmt.Printf("Mitarbeiter: %s, Stadt: %s, Fähigkeiten: %v",        emp.Name, emp.Address.City, emp.Skills)    // Ausgabe: Mitarbeiter: Alexei Ivanov, Stadt: Moskau, Fähigkeiten: [Go Python Docker]}

Für Arrays in Go werden Slices verwendet ([]string), und für verschachtelte Objekte separate Strukturen. Beim Parsen eines JSON-Arrays von Objekten kann