tatasusunan golang ke xml

Apabila golang menjadi semakin popular dalam bidang pembangunan web dan pengkomputeran awan, pemprosesan xml golang telah beransur-ansur mendapat perhatian. Dalam projek sebenar, kami selalunya perlu menghantar dan menyimpan data dalam format xml, dan kami juga perlu menghuraikan data daripada xml dan menukarnya menjadi tatasusunan pergi. Oleh itu, artikel ini akan memperkenalkan cara menukar tatasusunan go ke dalam format xml dan menggunakannya dalam pembangunan sebenar.

1. Pakej xml golang

pakej xml golang ialah pakej teras untuk memproses xml. Pakej xml Golang menyokong pengekodan dan penyahkodan pelbagai jenis seperti struktur, nombor dan rentetan. Antara fungsi yang disediakan oleh pakej ini, fungsi Marshal dan Unmarshal ialah dua fungsi yang paling biasa digunakan, yang digunakan untuk mensiri dan menghuraikan data xml masing-masing.

2. Tukar tatasusunan kepada xml

Walaupun pakej xml golang menyokong pengekodan dan penyahkodan pelbagai jenis, ia tidak menyediakan antara muka yang sepadan untuk bersiri dan penyahserilan tatasusunan. Oleh itu, apabila pengekodan dan penyahkodan tatasusunan xml, kita perlu menentukan sendiri kaedah penukaran.

1. Array kepada xml

Idea kami untuk menukar tatasusunan kepada format xml ialah: mula-mula menukar tatasusunan kepada struktur, dan kemudian menukar struktur kepada xml. Seterusnya, kami mula-mula mentakrifkan Pengguna jenis tersuai, yang mempunyai tiga medan: id, nama dan umur.

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

Kemudian tentukan jenis data Pengguna, yang juga mempunyai 3 medan, iaitu XMLName, Versi dan Item tatasusunan pengguna.

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

Seterusnya, kami mentakrifkan fungsi untuk menukar tatasusunan kepada format xml. Idea asas fungsi ini adalah untuk mencipta contoh jenis Pengguna, menukar setiap elemen dalam tatasusunan kepada jenis Pengguna, dan menambahnya pada tatasusunan Item Pengguna Akhir sekali, gunakan fungsi xml.Marshal untuk menukar Contoh pengguna ke dalam bait dalam 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)
}

Dalam kod di atas, pembolehubah arr merujuk kepada tatasusunan apa-apa jenis dan setiap elemen daripadanya adalah daripada jenis peta[rentetan]antara muka{}. Penegasan jenis digunakan di sini untuk memaksa pembolehubah jenis peta[rentetan]antara muka{} ke dalam jenis yang sepadan untuk mencapai penghuraian elemen dalam tatasusunan.

2. Xml kepada tatasusunan

Sama seperti menukar tatasusunan kepada xml, idea untuk menukar xml kepada tatasusunan ialah: mula-mula menukar xml kepada struktur, dan kemudian tukar struktur Tukar kepada tatasusunan jenis yang sepadan.

Fungsi Unmarshal disediakan dalam pakej xml golang, yang boleh menukar tatasusunan bait dalam format xml kepada struktur. Kod berikut menunjukkan cara menukar tatasusunan bait dalam format xml kepada contoh Pengguna:

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
}

Dalam kod di atas, kami menukar contoh jenis Pengguna yang dihuraikan daripada xml kepada jenis tatasusunan. Gelung for digunakan di sini untuk menukar setiap tika jenis Pengguna dalam tika Pengguna kepada jenis peta[rentetan]antara muka{} dan menambahkannya pada tatasusunan.

3. Ujian

Kami telah berjaya melaksanakan operasi asas menukar tatasusunan ke dalam format xml dan menukar format xml kepada tatasusunan Mari lakukan ujian:

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

Menjalankan perkara di atas kod, kita boleh melihat hasil berikut:

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

Ini bermakna kami berjaya menukar tatasusunan ke dalam format xml dan boleh menghuraikan data format xml dengan betul ke dalam tatasusunan jenis yang sepadan.

4. Ringkasan

Artikel ini terutamanya memperkenalkan cara menggunakan pakej xml golang untuk menukar tatasusunan kepada format xml dan menukar format xml kepada tatasusunan. Walaupun pakej xml golang sendiri tidak menyediakan sokongan yang sepadan untuk tatasusunan, kami boleh mensiri dan menyahsiri tatasusunan dengan menukar tatasusunan kepada struktur dan menukar struktur kepada xml. Dalam projek sebenar, kami perlu melaksanakan pembangunan tersuai mengikut keperluan khusus dan terus menambah baik serta mengoptimumkan antara muka untuk mencapai hasil penggunaan yang lebih baik.

Atas ialah kandungan terperinci tatasusunan golang ke xml. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!