Comment utiliser la sérialisation JSON personnalisée dans Go ?

Étant donné que les langages de programmation modernes ont des exigences de plus en plus élevées en matière de structure de données et de transmission réseau, le format JSON est également devenu un format d'échange de données important. JSON peut mieux transmettre les données et le langage Go devient de plus en plus populaire en raison de ses hautes performances et de son interface d'application simple. Dans Go, vous pouvez personnaliser la sérialisation JSON pour mieux répondre aux besoins de transmission de données. Cet article explique comment utiliser la sérialisation JSON personnalisée dans Go.

1. Qu'est-ce que la sérialisation JSON ?

La sérialisation JSON fait référence à la conversion d'un objet en une chaîne au format JSON et à son envoi à d'autres services ou clients pendant la transmission réseau afin qu'ils puissent lire et utiliser avec succès l'objet. Dans la chaîne JSON sérialisée, chaque nom d'attribut sera converti en chaîne et chaque valeur sera convertie en conséquence en type correspondant en JSON pour garantir des données universelles entre différentes langues.

2. Sérialisation JSON en Go

En langage Go, la sérialisation JSON peut être réalisée en utilisant « encoding/json » dans la bibliothèque standard. Lorsque la structure de données est une structure générale et une valeur distincte, vous pouvez directement utiliser la fonction Marshal de la bibliothèque standard pour la convertir en chaîne JSON correspondante, comme indiqué ci-dessous :

type User struct {
    Username string `json:"username"`
    Password string `json:"password"`
}

func main() {
    user := User{"Amy", "123456"}
    jsonStr, err := json.Marshal(user)
    if err != nil {
        panic(err)
    }
    fmt.Println(string(jsonStr))
}

La chaîne JSON de sortie est :

{"username":"Amy","password":"123456"}

Trois , Sérialisation JSON personnalisée

En langage Go, vous pouvez personnaliser la sérialisation JSON en implémentant les méthodes MarshalJSON et UnmarshalJSON. La méthode MarshalJSON est utilisée pour convertir une structure ou un type en chaîne JSON, tandis qu'UnmarshalJSON peut convertir une chaîne JSON en structure ou type correspondant.

Avant d'implémenter la sérialisation JSON personnalisée, vous devez comprendre plusieurs balises de structure :

1. json : Lors de la définition de la structure, vous pouvez ajouter 'json:"custom_name"' avant le champ pour définir le champ dans la sérialisation. Le nom en tant que Chaîne JSON.
2. omitempty : Lorsque la valeur du champ n'est pas vide, le champ sera inclus lors de la sérialisation, et lorsque le champ est vide, le champ ne sera pas inclus.

Ensuite, prenons le salaire comme exemple pour implémenter une sérialisation JSON personnalisée.

type Salary struct {
    Basic int `json:"basic,omitempty"`
    Bonus int `json:"bonus,omitempty"`
}

func (s Salary) MarshalJSON() ([]byte, error) {
    var result string
    if s.Bonus != 0 {
        result = fmt.Sprintf(""basic":%d,"bonus":%d", s.Basic, s.Bonus)
    } else {
        result = fmt.Sprintf(""basic":%d", s.Basic)
    }
    return []byte("{" + result + "}"), nil
}

func main() {
    salary := Salary{
        Basic:  10000,
        Bonus:  5000,
    }
    jsonStr, err := json.Marshal(salary)
    if err != nil {
        panic(err)
    }
    fmt.Println(string(jsonStr))
}

Exécutez le code ci-dessus et la chaîne JSON de sortie est :

{"basic":10000,"bonus":5000}

Ici, nous avons implémenté une méthode MarshalJSON personnalisée, uniquement lorsque le champ Bonus n'est pas 0, sa valeur est affichée dans Marshal lorsqu'il l'est. 0, ce champ n'est pas affiché.

4. Formatage JSON personnalisé

En langage Go, vous pouvez également personnaliser le formatage JSON en implémentant les méthodes MarshalText et UnmarshalText. La méthode MarshalText est utilisée pour convertir une structure ou un type en texte au format []byte, tandis qu'UnmarshalText peut convertir du texte au format []byte dans la structure ou le type correspondant.

Prenez la date comme exemple, personnalisez une fonction de formatage JSON et affichez un format similaire à "2022-09-21".

type Date struct {
    time.Time
}

func (d Date) MarshalText() ([]byte, error) {
    return []byte(d.Time.Format("2006-01-02")), nil
}

func (d *Date) UnmarshalText(text []byte) error {
    parse, err := time.Parse("2006-01-02", string(text))
    if err != nil {
        return err
    }
    d.Time = parse
    return nil
}

func main() {
    date := Date{time.Now()}
    jsonStr, err := json.Marshal(date)
    if err != nil {
        panic(err)
    }
    fmt.Println(string(jsonStr))

    var newDate Date
    err = json.Unmarshal([]byte(""2022-09-21""), &newDate)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println(newDate.Time)
}

Exécutez le code ci-dessus et la chaîne JSON de sortie est :

"2022-09-21"
2022-09-21 00:00:00 +0000 UTC

Comme le montre l'exemple ci-dessus, lors de la personnalisation de la sérialisation et de la désérialisation JSON, vous devez comprendre les principes de la sérialisation JSON et l'implémentation de la bibliothèque standard. Utilisez-le de manière flexible dans le développement réel. Dans le même temps, nous pouvons également définir une méthode de formatage JSON qui répond aux exigences de nos propres objets, qui fournit des outils et un support de base pour mieux répondre aux besoins de transmission de données dans différents scénarios.

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!