Golang-Objekt gegen JSON

Das Konvertieren eines Objekts in JSON in Golang ist eine sehr häufige Sache. Ich glaube, die meisten Golang-Entwickler werden damit konfrontiert sein. In diesem Artikel werden die Methoden und Techniken zum Konvertieren eines Objekts in JSON in Golang vorgestellt.

1. Encoding/JSON-Paket verwenden

Schauen Sie sich zunächst das Encoding/JSON-Paket an, das in der Golang-Standardbibliothek bereitgestellt wird. Dieses Paket bietet sehr einfache und benutzerfreundliche Funktionen und Typen, mit denen wir problemlos ein Objekt in eine JSON-formatierte Zeichenfolge oder eine JSON-formatierte Zeichenfolge in ein Objekt konvertieren können.

Es ist zu beachten, dass das Objekt exportierbar sein muss (d. h. der erste Buchstabe wird groß geschrieben), andernfalls kann das JSON-Paket nicht auf seine Felder zugreifen.

Das Folgende ist ein einfacher Beispielcode, der das Paket „encoding/json“ verwendet, um das Student-Objekt in eine Zeichenfolge im JSON-Format zu konvertieren:

package main

import (
    "encoding/json"
    "fmt"
)

type Student struct {
    Name  string
    Age   int
    Score float64
}

func main() {
    s := Student{
        Name:  "Tom",
        Age:   18,
        Score: 90.5,
    }
    b, err := json.Marshal(s)
    if err != nil {
        fmt.Println("json.Marshal failed:", err)
        return
    }
    fmt.Println(string(b))
}

Ausgabe:

{"Name":"Tom","Age":18,"Score":90.5}

# 🎜🎜#Ja Wie Sie sehen, kann die vom JSON-Paket bereitgestellte Marshal-Funktion ein Strukturobjekt in eine Zeichenfolge im JSON-Format serialisieren.

Ein komplexes Objekt können wir auch problemlos in eine Zeichenfolge im JSON-Format serialisieren. Das folgende Array besteht beispielsweise aus mehreren Student-Objekten:

package main

import (
    "encoding/json"
    "fmt"
)

type Student struct {
    Name  string
    Age   int
    Score float64
}

func main() {
    students := []Student{
        {Name: "Tom", Age: 18, Score: 90.5},
        {Name: "Jerry", Age: 19, Score: 96.5},
        {Name: "Alice", Age: 17, Score: 85.5},
    }
    b, err := json.Marshal(students)
    if err != nil {
        fmt.Println("json.Marshal failed:", err)
        return
    }
    fmt.Println(string(b))
}

Ausgabe:

[{"Name":"Tom","Age":18,"Score":90.5},{"Name":"Jerry","Age":19,"Score":96.5},{"Name":"Alice","Age":17,"Score":85.5}]

In ähnlicher Weise können wir die vom JSON-Paket bereitgestellte Unmarshal-Funktion verwenden, um ein Zeichen in zu konvertieren JSON-Format Die Zeichenfolge wird in ein Objekt analysiert. Zum Beispiel:

package main

import (
    "encoding/json"
    "fmt"
)

type Point struct {
    X int `json:"x"`
    Y int `json:"y"`
}

type Line struct {
    Start Point `json:"start"`
    End   Point `json:"end"`
}

func main() {
    jsonStr := `
    {
        "start": {
            "x": 1,
            "y": 2
        },
        "end": {
            "x": 3,
            "y": 4
        }
    }`
    var line Line
    err := json.Unmarshal([]byte(jsonStr), &line)
    if err != nil {
        fmt.Println("json.Unmarshal failed:", err)
        return
    }
    fmt.Printf("%#v
", line)
}

Ausgabe:

main.Line{Start:main.Point{X:1, Y:2}, End:main.Point{X:3, Y:4}}

In diesem Beispielcode definieren wir ein Linienobjekt, das zwei Punktobjekte enthält. Verwenden Sie die vom JSON-Paket bereitgestellte Unmarshal-Funktion, um eine JSON-Formatzeichenfolge in ein Line-Objekt zu analysieren und diese dann auszugeben.

Angepasste JSON-Serialisierung und -Deserialisierung durch Struktur-Tags

Wenn wir die Ausgabe des JSON-Formats anpassen möchten, z. B. Was soll ich tun, wenn Ich ändere den Namen eines bestimmten Feldes? Zu diesem Zeitpunkt ist das Struktur-Tag in Golang praktisch.

In Golang ist das Struktur-Tag eine Möglichkeit, Strukturfelder mit Anmerkungen zu versehen, was durch Hinzufügen einer Zeichenfolge nach dem Feldtyp erreicht werden kann. Wenn wir die Serialisierung und Deserialisierung von JSON-Paketen verwenden, können wir das Struktur-Tag verwenden, um den Serialisierungs- und Deserialisierungsprozess zu steuern.

Das Folgende ist ein einfacher Beispielcode, der zeigt, wie das Struktur-Tag verwendet wird, um den Prozess der JSON-Serialisierung und -Deserialisierung zu steuern:

package main

import (
    "encoding/json"
    "fmt"
)

type Student struct {
    Name  string `json:"name"`
    Age   int    `json:"age"`
    Score float64
}

func main() {
    s := Student{
        Name:  "Tom",
        Age:   18,
        Score: 90.5,
    }
    fmt.Println("*** 序列化 ***")
    b, err := json.Marshal(s)
    if err != nil {
        fmt.Println("json.Marshal failed:", err)
        return
    }
    fmt.Println(string(b))

    fmt.Println("*** 反序列化 ***")
    jsonStr := `{"name":"Tom","age":18,"Score":90.5}`
    var student Student
    err = json.Unmarshal([]byte(jsonStr), &student)
    if err != nil {
        fmt.Println("json.Unmarshal failed:", err)
        return
    }
    fmt.Printf("%#v
", student)
}

Ausgabe:

*** 序列化 ***
{"name":"Tom","age":18,"Score":90.5}
*** 反序列化 ***
main.Student{Name:"Tom", Age:18, Score:90.5}

#🎜 🎜#Hier markieren wir das Namensfeld im Student-Objekt als „Name“, sodass bei der Serialisierung mit der json.Marshal-Funktion sein Name in „Name“ geändert wird. Ebenso wird beim Deserialisieren mit der Funktion json.Unmarshal „name“ automatisch als Feld „Name“ erkannt.

Durch die Form des Struktur-Tags können wir auch die Sichtbarkeit von Feldern in der JSON-Ausgabe steuern. Zum Beispiel:

package main

import (
    "encoding/json"
    "fmt"
)

type Student struct {
    Name  string `json:"name,omitempty"`
    Age   int    `json:"age"`
    Score float64
}

func main() {
    s := Student{
        Age:   18,
        Score: 90.5,
    }
    fmt.Println("*** 序列化 ***")
    b, err := json.Marshal(s)
    if err != nil {
        fmt.Println("json.Marshal failed:", err)
        return
    }
    fmt.Println(string(b))

    fmt.Println("*** 反序列化 ***")
    jsonStr := `{"name":"Tom","age":18,"Score":90.5}`
    var student Student
    err = json.Unmarshal([]byte(jsonStr), &student)
    if err != nil {
        fmt.Println("json.Unmarshal failed:", err)
        return
    }
    fmt.Printf("%#v
", student)
}

Ausgabe:

*** 序列化 ***
{"age":18,"Score":90.5}
*** 反序列化 ***
main.Student{Name:"Tom", Age:18, Score:90.5}

Hier markieren wir das Feld „Name“ als „omitempty“, was bedeutet, dass, wenn der Wert des Felds „Name“ Null ist (d. h. „“ ), dann wird dieses Feld bei der JSON-Ausgabe ignoriert.

Bibliotheken von Drittanbietern verwenden

Wenn wir eine komplexere JSON-Serialisierung und -Deserialisierung durchführen müssen, ist die Golang-Standardbibliothek möglicherweise etwas nicht geeignet genug Kraft. Derzeit können wir einige Bibliotheken von Drittanbietern verwenden, um flexiblere Abläufe zu erreichen.

Das Folgende ist ein Beispielcode, der eine Drittanbieterbibliothek für die JSON-Serialisierung und -Deserialisierung verwendet. Dieser Beispielcode verwendet das Paket json-iterator/go. Dieses Paket ist derzeit eine der schnellsten Golang-JSON-Bibliotheken . eins.

package main

import (
    "fmt"
    "github.com/json-iterator/go"
)

type Student struct {
    Name  string `json:"name"`
    Age   int    `json:"age"`
    Score float64 `json:"score,omitempty"`
}

func main() {
    student := Student{
        Name:  "Tom",
        Age:   18,
        Score: 0,
    }
    fmt.Println("*** 序列化 ***")
    json := jsoniter.ConfigCompatibleWithStandardLibrary
    b, err := json.Marshal(student)
    if err != nil {
        fmt.Println("json.Marshal failed:", err)
        return
    }
    fmt.Println(string(b))

    fmt.Println("*** 反序列化 ***")
    jsonStr := `{"name":"Tom","age":18}`
    err = json.Unmarshal([]byte(jsonStr), &student)
    if err != nil {
        fmt.Println("json.Unmarshal failed:", err)
        return
    }
    fmt.Printf("%#v
", student)
}

Ausgabe:

*** 序列化 ***
{"name":"Tom","age":18}
*** 反序列化 ***
main.Student{Name:"Tom", Age:18, Score:0}

Es ist zu beachten, dass die Verwendung von Bibliotheken von Drittanbietern zwar flexiblere JSON-Operationen ermöglichen kann, aber auch zu Leistungseinbußen oder Codekomplexitätsproblemen führen kann als Ergänzung müssen je nach Szenario ausgewählt werden.

In diesem Artikel werden verschiedene Methoden und Techniken zum Konvertieren von Objekten in JSON in Golang vorgestellt. Ich hoffe, dieser Artikel kann den Lesern hilfreich sein.

Das obige ist der detaillierte Inhalt vonGolang-Objekt gegen JSON. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!