Comment effectuer une conversion de structure dans Golang

Le langage Golang est un langage de programmation orienté objet, hautement lisible et maintenable. Pour la plupart des développeurs, il est plus pratique et plus rapide d'utiliser Golang pour le développement. En Golang, struct est un type de données très courant, qui peut représenter un ensemble d'attributs d'un objet. Dans le développement réel, il est souvent nécessaire d'effectuer une conversion entre les structures. Aujourd'hui, nous allons apprendre comment Golang effectue la conversion de structures.

Définissons la structure

Tout d'abord, définissons une structure :

type Person struct {
    Name    string
    Age     int
    Address Address
}

type Address struct {
    Province string
    City     string
    Street   string
}

Dans le code ci-dessus, nous avons défini deux structures, l'une est Personne, qui contient les propriétés de nom, d'âge et d'adresse, où Adresse est une structure imbriquée.

Convertir la structure en JSON

Dans le développement réel, nous avons souvent besoin de convertir la structure au format JSON. Le package d'encodage/json intégré dans Golang fournit des fonctions pratiques d'encodage et de décodage JSON. Nous pouvons utiliser ce package pour convertir des structures en données au format JSON.

import "encoding/json"

func main() {
    person := Person{Name: "Tom", Age: 18, Address: Address{Province: "Beijing", City: "Beijing", Street: "Wudaokou"}}
    jsonBytes, err := json.Marshal(person)
    if err != nil {
        fmt.Println(err)
    }
    fmt.Println(string(jsonBytes))
}

Dans le code ci-dessus, nous créons d'abord une instance Person, puis appelons json.Marshal() pour convertir l'instance en données au format JSON. Pendant le processus de conversion, s'il y a une erreur, un message d'erreur sera affiché, sinon la chaîne du résultat converti sera affichée.

Convertir JSON en structure

En plus de convertir des structures au format JSON, nous devons souvent également convertir des données au format JSON en structures. Dans l'exemple ci-dessus, nous avons converti la personne au format JSON, maintenant nous transformons les données JSON en structure.

jsonStr := `{"Name":"Tom","Age":18,"Address":{"Province":"Beijing","City":"Beijing","Street":"Wudaokou"}}`
person := Person{}
err := json.Unmarshal([]byte(jsonStr), &person)
if err != nil {
    fmt.Println(err)
}
fmt.Println(person)

Dans le code ci-dessus, nous définissons d'abord les données au format JSON comme jsonStr, puis appelons json.Unmarshal() pour les convertir en une structure Person. De même, si une erreur se produit pendant le processus de conversion, le message d'erreur est généré, sinon l'instance de structure Person convertie est générée.

Conversion de champ

Dans certains cas, les noms de champ des données ne correspondent pas aux noms de champ dans la structure. Dans ce cas, une conversion de champ est requise. Dans Golang, cela peut être réalisé en changeant le nom d'attribut de la structure en Tag.

type Person struct {
    Name    string `json:"name"`
    Age     int    `json:"age"`
    Address Address
}

type Address struct {
    Province string `json:"province"`
    City     string `json:"city"`
    Street   string `json:"street"`
}

Dans le code ci-dessus, nous avons ajouté la balise json avant le nom de l'attribut de structure, qui spécifie le nom de l'attribut JSON. Pendant le processus de conversion, si la balise existe, la balise prévaudra.

Les tableaux existent dans les structures

Dans les structures, il peut y avoir des attributs contenant des tableaux. Dans ce cas, nous devons parcourir le tableau.

type Person struct {
    Name    string    `json:"name"`
    Age     int       `json:"age"`
    Address []Address `json:"address"`
}

type Address struct {
    Province string `json:"province"`
    City     string `json:"city"`
    Street   string `json:"street"`
}

func main() {
    jsonStr := `{"name":"Tom","age":18,"address":[{"province":"Beijing","city":"Beijing","street":"Wudaokou"},{"province":"Henan","city":"Kaifeng","street":"Longting"}]}`
    person := Person{}
    err := json.Unmarshal([]byte(jsonStr), &person)
    if err != nil {
        fmt.Println(err)
    }
    for _, a := range person.Address {
        fmt.Println(a.Province, a.City, a.Street)
    }
}

Dans le code ci-dessus, la structure Person contient un tableau d'adresses que nous devons parcourir. Pendant le processus de conversion, nous pouvons utiliser Unmarshal pour convertir les données au format JSON en instances de structure Personne, puis parcourir le tableau Adresse pour afficher les attributs Province, Ville et Rue de chaque instance d'adresse.

Résumé

En Golang, la conversion de structure est une opération relativement fréquente. Grâce à l'introduction de cet article, nous avons appris comment Golang convertit struct et JSON entre eux. Pour certains cas particuliers, tels que la conversion de champ et le parcours de tableau, une compréhension et un fonctionnement plus approfondis sont nécessaires. La fonction de conversion de structure de Golang rend notre développement plus pratique et plus rapide.

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!