Arbeiten mit JSON in Go: Parsing und Serialisierung für Anfänger

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 und Microservices. Dank seiner Einfachheit und Lesbarkeit ist JSON zum Standard für REST-APIs, Konfigurationsdateien und die Speicherung strukturierter Daten geworden.

Die Sprache Go (Golang) bietet eine integrierte leistungsstarke Unterstützung für JSON über das Paket encoding/json. Dieses Paket ermöglicht es, Go-Strukturen einfach in JSON zu konvertieren (Serialisierung) und umgekehrt (Deserialisierung oder Parsing).

In diesem Artikel behandeln wir die Grundlagen der Arbeit mit JSON in Go: von einfachen Beispielen bis zur Verarbeitung komplexer verschachtelter Strukturen und Fehler. Das Material richtet sich an Anfänger, die bereits mit den Grundlagen der Go-Syntax vertraut sind.

Serialisierung: Konvertierung von Go-Strukturen in JSON

Serialisierung (Kodierung) ist der Prozess der Umwandlung von Daten aus der internen Go-Darstellung (Strukturen, Slices, Maps) in einen JSON-String. In Go wird dafür die Funktion json.Marshal() verwendet.

Basisbeispiel der Serialisierung

package main\n\nimport (\n    "encoding/json"\n    "fmt"\n)\n\ntype Person struct {\n    Name string\n    Age  int\n    City string\n}\n\nfunc main() {\n    person := Person{\n        Name: "Ivan Petrov",\n        Age:  30,\n        City: "Moskau",\n    }\n\n    jsonBytes, err := json.Marshal(person)\n    if err != nil {\n        fmt.Println("Serialisierungsfehler:", err)\n        return\n    }\n\n    fmt.Println(string(jsonBytes))\n    // Ausgabe: {"Name":"Ivan Petrov","Age":30,"City":"Moskau"}\n}

Beachten Sie: json.Marshal() gibt ein Byte-Slice ([]byte) zurück, daher konvertieren wir es mit string() in einen String.

Formatierte Ausgabe mit json.MarshalIndent

Für Debugging oder lesbare Ausgabe verwenden Sie json.MarshalIndent():

jsonBytes, err := json.MarshalIndent(person, "", "  ")\nif err != nil {\n    fmt.Println("Fehler:", err)\n    return\n}\nfmt.Println(string(jsonBytes))\n// Ausgabe:\n// {\n//   "Name": "Ivan Petrov",\n//   "Age": 30,\n//   "City": "Moskau"\n// }

Serialisierung von Slices und Maps

Go ermöglicht die Serialisierung nicht nur von Strukturen, sondern auch von anderen Datentypen:

// Slice von Strukturen\npeople := []Person{\n    {Name: "Anna", Age: 25, City: "SPb"},\n    {Name: "Peter", Age: 35, City: "Kasan"},\n}\njsonBytes, _ := json.Marshal(people)\nfmt.Println(string(jsonBytes))\n// Ausgabe: [{"Name":"Anna","Age":25,"City":"SPb"},{"Name":"Peter","Age":35,"City":"Kasan"}]\n\n// Map\nscores := map[string]int{"Algebra": 5, "Physik": 4, "Informatik": 5}\njsonBytes, _ = json.Marshal(scores)\nfmt.Println(string(jsonBytes))\n// Ausgabe: {"Algebra":5,"Informatik":5,"Physik":4}

JSON-Parsing: Konvertierung von JSON in Go-Strukturen

Parsing (Deserialisierung) ist der umgekehrte Prozess: Aus einem JSON-String erhalten wir eine Go-Struktur. Dafür wird die Funktion json.Unmarshal() verwendet.

Parsing in eine Struktur

package main\n\nimport (\n    "encoding/json"\n    "fmt"\n)\n\ntype Person struct {\n    Name string\n    Age  int\n    City string\n}\n\nfunc main() {\n    jsonString := `{"Name":"Ivan Petrov","Age":30,"City":"Moskau"}`\n\n    var person Person\n    err := json.Unmarshal([]byte(jsonString), &person)\n    if err != nil {\n        fmt.Println("Parsing-Fehler:", err)\n        return\n    }\n\n    fmt.Printf("Name: %s, Alter: %d, Stadt: %s\\n", person.Name, person.Age, person.City)\n    // Ausgabe: Name: Ivan Petrov, Alter: 30, Stadt: Moskau\n}

Wichtig: Übergeben Sie einen Zeiger auf die Struktur (&person), sonst kann Unmarshal ihre Felder nicht ändern.

Parsing in map[string]interface{}

Wenn die Datenstruktur im Voraus unbekannt ist, können Sie den universellen Typ verwenden:

jsonString := `{"name":"Anna","