Golang-Array in XML konvertieren

Da Golang in den Bereichen Webentwicklung und Cloud Computing immer beliebter wird, hat die XML-Verarbeitung von Golang nach und nach Beachtung gefunden. In tatsächlichen Projekten müssen wir häufig Daten im XML-Format übertragen und speichern. Außerdem müssen wir die Daten aus XML analysieren und in ein Go-Array konvertieren. Daher wird in diesem Artikel erläutert, wie man Go-Arrays in das XML-Format konvertiert und in der tatsächlichen Entwicklung verwendet.

1. Das XML-Paket von Golang

Das XML-Paket von Golang ist das Kernpaket für die Verarbeitung von XML. Es ermöglicht das Parsen von der XML- zur Go-Datenstruktur und von der Go-Datenstruktur zur XML-Serialisierungsfunktion . Das XML-Paket von Golang unterstützt die Kodierung und Dekodierung verschiedener Typen wie Strukturen, Zahlen und Zeichenfolgen. Unter den von diesem Paket bereitgestellten Funktionen sind die Funktionen Marshal und Unmarshal die beiden am häufigsten verwendeten Funktionen, die zum Serialisieren bzw. Analysieren von XML-Daten verwendet werden.

2. Array zu XML

Obwohl das XML-Paket von Golang die Kodierung und Dekodierung verschiedener Typen unterstützt, bietet es keine entsprechende Serialisierung und Deserialisierung der Array-Schnittstelle. Daher müssen wir beim Kodieren und Dekodieren von XML-Arrays die Konvertierungsmethode selbst definieren.

1. Array in XML

Unsere Idee, das Array in das XML-Format zu konvertieren, ist: Konvertieren Sie zuerst das Array in eine Struktur und dann die Struktur In XML konvertieren. Als Nächstes definieren wir zunächst einen benutzerdefinierten Benutzertyp, der drei Felder enthält: ID, Name und Alter.

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

Definieren Sie dann einen Benutzerdatentyp, der auch drei Felder enthält, nämlich XMLName, Version und Benutzerarray-Elemente.

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

Als nächstes definieren wir eine Funktion zum Konvertieren des Arrays in das XML-Format. Die Grundidee dieser Funktion besteht darin, eine Instanz des Users-Typs zu erstellen, jedes Element im Array in den User-Typ zu konvertieren und es zum Items-Array von Users hinzuzufügen. Verwenden Sie abschließend die Funktion xml.Marshal, um das zu konvertieren Benutzerinstanz in Bytes im XML-Format.

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

Im obigen Code bezieht sich die Variable arr auf ein Array eines beliebigen Typs, und jedes Element davon ist vom Typ map[string]interface{}. Typzusicherungen werden hier verwendet, um Variablen des Typs „map[string]interface{}“ in den entsprechenden Typ zu zwingen, um eine Analyse der Elemente im Array zu erreichen.

2. Xml in Array

Die Idee beim Konvertieren von XML in ein Array ist genau wie beim Konvertieren eines Arrays in XML: Zuerst konvertieren xml in einen Strukturkörper umwandeln und dann die Struktur in ein Array des entsprechenden Typs konvertieren.

Die Unmarshal-Funktion ist im XML-Paket von Golang enthalten und kann ein Byte-Array im XML-Format in eine Struktur konvertieren. Der folgende Code zeigt, wie man ein Byte-Array im XML-Format in eine Users-Instanz konvertiert:

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
}

Im obigen Code konvertieren wir die aus XML analysierte Users-Typinstanz in einen Array-Typ. Hier wird eine for-Schleife verwendet, um jede Benutzertypinstanz in der Benutzerinstanz in den Typ „map[string]interface{}“ zu konvertieren und sie dem Array hinzuzufügen.

3. Test

Wir haben die grundlegenden Vorgänge zum Konvertieren von Arrays in das XML-Format und zum Konvertieren des XML-Formats in Arrays erfolgreich implementiert. Führen wir den folgenden Test durch: #🎜🎜 #

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

Führen Sie den obigen Code aus. Wir können die folgenden Ergebnisse sehen:

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]] 

Das bedeutet, dass wir das Array erfolgreich in das XML-Format konvertiert haben und die Daten im XML-Format korrekt in ein Array des entsprechenden Typs analysieren können.

4. Zusammenfassung

In diesem Artikel wird hauptsächlich die Verwendung des XML-Pakets von Golang zum Konvertieren von Arrays in das XML-Format und die Konvertierung des XML-Formats in Arrays vorgestellt. Obwohl das XML-Paket von Golang selbst keine entsprechende Unterstützung für Arrays bietet, können wir Arrays serialisieren und deserialisieren, indem wir Arrays in Strukturen und Strukturen in XML konvertieren. In tatsächlichen Projekten müssen wir eine maßgeschneiderte Entwicklung entsprechend den spezifischen Anforderungen durchführen und die Schnittstelle kontinuierlich verbessern und optimieren, um bessere Nutzungsergebnisse zu erzielen.

Das obige ist der detaillierte Inhalt vonGolang-Array in XML konvertieren. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!