tableau golang en XML

Avec la popularité croissante de Golang dans le domaine du développement Web et du cloud computing, le traitement XML de Golang a progressivement retenu l'attention. Dans les projets réels, nous devons souvent transmettre et stocker des données au format XML, et nous devons également analyser les données XML et les convertir en un tableau Go. Par conséquent, cet article expliquera comment convertir des tableaux go au format XML et les utiliser dans le développement réel.

1. Le package XML de Golang

Le package XML de Golang est le package de base pour le traitement du XML. Il fournit l'analyse de la structure de données XML et la fonction de sérialisation de la structure de données Go à XML. Le package XML de Golang prend en charge l'encodage et le décodage de divers types tels que les structures, les nombres et les chaînes. Parmi les fonctions fournies par ce package, les fonctions Marshal et Unmarshal sont les deux fonctions les plus couramment utilisées, qui sont respectivement utilisées pour sérialiser et analyser les données XML.

2. Convertir un tableau en XML

Bien que le package XML de Golang prenne en charge l'encodage et le décodage de différents types, il ne fournit pas d'interfaces correspondantes pour la sérialisation et la désérialisation des tableaux. Par conséquent, lors de l’encodage et du décodage des tableaux XML, nous devons définir nous-mêmes la méthode de conversion.

1. Array to XML

Notre idée pour convertir un tableau au format XML est la suivante : convertissez d'abord le tableau en structure, puis convertissez la structure en XML. Ensuite, nous définissons d'abord un type personnalisé Utilisateur, qui comporte trois champs : identifiant, nom et âge.

type User struct {
    Id   string `xml:"id"`
    Name string `xml:"name"`
    Age  int    `xml:"age"`
}

Définissez ensuite un type de données Users, qui comporte également 3 champs, à savoir XMLName, Version et user array Items.

type Users struct {
    XMLName xml.Name `xml:"users"`
    Version string   `xml:"version,attr"`
    Items   []User   `xml:"user"`
}

Ensuite, nous définissons une fonction pour convertir le tableau au format XML. L'idée de base de cette fonction est de créer une instance du type Users, de convertir chaque élément du tableau en type User et de l'ajouter au tableau Items des Users. Enfin, utilisez la fonction xml.Marshal pour convertir le. Instance des utilisateurs en octets au format XML.

func ArrayToXml(arr []interface{}) ([]byte, error) {
    var users Users
    users.Version = "1.0"
    for i := 0; i < len(arr); i++ {
        var user User
        if v, ok := arr[i].(map[string]interface{}); ok {
            user.Id = v["id"].(string)
            user.Name = v["name"].(string)
            user.Age = v["age"].(int)
            users.Items = append(users.Items, user)
        }
    }
    return xml.Marshal(users)
}

Dans le code ci-dessus, la variable arr fait référence à un tableau de n'importe quel type, et chaque élément de celui-ci est de type map[string]interface{}. Les assertions de type sont utilisées ici pour forcer les variables du type map[string]interface{} dans le type correspondant afin de réaliser l'analyse des éléments du tableau.

2. Xml en tableau

Tout comme la conversion d'un tableau en XML, l'idée de la conversion de XML en tableau est la suivante : convertissez d'abord le XML en une structure, puis convertissez la structure en un tableau du type correspondant.

La fonction Unmarshal est fournie dans le package XML de Golang, qui peut convertir un tableau d'octets au format XML en une structure. Le code suivant montre comment convertir un tableau d'octets au format XML en une instance Users :

func XmlToArray(data []byte) ([]interface{}, error) {
    var users Users
    var arr []interface{}
    err := xml.Unmarshal(data, &users)
    if err != nil {
        return nil, err
    }
    for _, item := range users.Items {
        m := make(map[string]interface{})
        m["id"] = item.Id
        m["name"] = item.Name
        m["age"] = item.Age
        arr = append(arr, m)
    }
    return arr, nil
}

Dans le code ci-dessus, nous convertissons l'instance de type Users analysée à partir de XML en un type tableau. Une boucle for est utilisée ici pour convertir chaque instance de type User dans l'instance Users en type map[string]interface{} et l'ajouter au tableau.

3. Test

Nous avons implémenté avec succès les opérations de base de conversion de tableaux au format XML et de conversion du format XML en tableaux :

func main() {
    arr := make([]interface{}, 0)
    m1 := map[string]interface{}{
        "id":   "1",
        "name": "Tom",
        "age":  20,
    }
    m2 := map[string]interface{}{
        "id":   "2",
        "name": "Jerry",
        "age":  22,
    }
    arr = append(arr, m1)
    arr = append(arr, m2)

    data, err1 := ArrayToXml(arr)
    if err1 != nil {
        fmt.Println("error:", err1)
        return
    }
    fmt.Println("array to xml:", string(data))

    arr2, err2 := XmlToArray(data)
    if err2 != nil {
        fmt.Println("error:", err2)
        return
    }
    fmt.Println("xml to array:", arr2)
}

Exécutez le code ci-dessus, nous pouvons voir les résultats suivants :

array to xml: <?xml version="1.0" encoding="UTF-8"?>
<users version="1.0">
    <user>
        <id>1</id><name>Tom</name><age>20</age>
    </user>
    <user>
        <id>2</id><name>Jerry</name><age>22</age>
    </user>
</users>

xml to array: [map[id:1 name:Tom age:20] map[id:2 name:Jerry age:22]] 

. Cela signifie que nous avons réussi à convertir le tableau au format XML et que nous pouvons analyser correctement les données au format XML dans un tableau du type correspondant.

4. Résumé

Cet article présente principalement comment utiliser le package XML de Golang pour convertir des tableaux au format XML et convertir le format XML en tableaux. Bien que le package XML de Golang lui-même ne fournisse pas de prise en charge correspondante pour les tableaux, nous pouvons sérialiser et désérialiser les tableaux en convertissant les tableaux en structures et en convertissant les structures en XML. Dans les projets réels, nous devons effectuer un développement personnalisé en fonction de besoins spécifiques et améliorer et optimiser continuellement l'interface pour obtenir de meilleurs résultats d'utilisation.

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!