Objet Golang à json

Convertir un objet en json dans Golang est une chose très courante, je pense que la plupart des développeurs Golang le rencontreront. Cet article partagera les méthodes et techniques permettant de convertir un objet en json dans Golang.

1. Utilisation du package encoding/json

Tout d'abord, regardons le package encoding/json fourni dans la bibliothèque standard golang. Ce package fournit des fonctions et des types très simples et faciles à utiliser qui nous permettent de convertir facilement un objet en une chaîne au format json ou de convertir une chaîne au format json en un objet.

Il est à noter que l'objet doit être exportable (c'est-à-dire que la première lettre est en majuscule), sinon le package json ne pourra pas accéder à ses champs.

Ce qui suit est un exemple de code simple qui utilise le package encoding/json pour convertir un objet Student en une chaîne au format json :

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))
}

Sortie :

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

Comme vous pouvez le voir, la fonction Marshal fournie par le package json peut sérialiser un objet de structure dans une chaîne de format json.

Pour un objet complexe, nous pouvons également le sérialiser facilement dans une chaîne au format json. Par exemple, le tableau suivant se compose de plusieurs objets Student :

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))
}

Sortie :

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

De même, nous pouvons utiliser la fonction Unmarshal fournie par le package json pour analyser une chaîne au format json dans un objet. Par exemple :

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)
}

Sortie :

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

Dans cet exemple de code, nous définissons un objet Line, qui contient deux objets Point. Utilisez la fonction Unmarshal fournie par le package json pour analyser une chaîne au format json dans un objet Line, puis la générer.

2. Sérialisation et désérialisation json personnalisées via des balises de structure

Que devons-nous faire si nous voulons personnaliser la sortie au format json, comme modifier le nom d'un champ ? À l’heure actuelle, la balise struct dans golang est utile.

En Golang, la balise struct est un moyen d'annoter les champs de structure, ce qui peut être réalisé en ajoutant une chaîne après le type de champ. Lors de l'utilisation de la sérialisation et de la désérialisation du package json, nous pouvons utiliser la balise struct pour contrôler le processus de sérialisation et de désérialisation.

Ce qui suit est un exemple de code simple qui montre comment utiliser la balise struct pour contrôler le processus de sérialisation et de désérialisation json :

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)
}

Sortie :

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

Ici, nous marquons le champ Nom dans l'objet Étudiant comme "nom", Lorsqu'il est sérialisé à l'aide de la fonction json.Marshal, son nom sera changé en « nom ». De même, lors de la désérialisation à l'aide de la fonction json.Unmarshal, « nom » sera automatiquement reconnu comme le champ Nom.

Grâce au formulaire de balise struct, nous pouvons également contrôler la visibilité des champs dans la sortie json. Par exemple :

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)
}

Sortie :

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

Ici, nous marquons le champ Nom comme "omitempty", ce qui signifie que si la valeur du champ Nom est zéro (c'est-à-dire ""), alors ce champ sera ignoré lors de la sortie de json.

3. Utiliser des bibliothèques tierces

Lorsque nous devons effectuer une sérialisation et une désérialisation json plus complexes, la bibliothèque standard golang peut être un peu faible. À l'heure actuelle, nous pouvons utiliser certaines bibliothèques tierces pour nous aider à réaliser des opérations plus flexibles.

Ce qui suit est un exemple de code qui utilise une bibliothèque tierce pour la sérialisation et la désérialisation json. Cet exemple de code utilise le package json-iterator/go, qui est actuellement l'une des bibliothèques json golang les plus rapides.

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)
}

Sortie :

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

Il convient de noter que bien que l'utilisation de bibliothèques tierces puisse permettre d'obtenir des opérations json plus flexibles, elle peut également introduire des problèmes tels qu'une réduction des performances ou une complexité accrue du code, et doit être sélectionnée en fonction de scénarios spécifiques.

Cet article présente plusieurs méthodes et techniques pour convertir des objets en json dans Golang. J'espère que cet article pourra être utile aux lecteurs.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!