Bagaimana untuk Cekap Berulang Melalui JSON Bersarang Tahap Kedua dalam Go?

Menggelung/Mengulang ke atas JSON Bersarang Tahap Kedua dalam Go

Soalan ini melibatkan lelaran melalui struktur JSON bersarang kompleks dalam Go, khususnya memfokuskan pada peringkat kedua bersarang. Input JSON mengandungi berbilang peringkat objek dan tatasusunan bersarang, dan tugasnya adalah untuk mengakses dan memproses pasangan nilai kunci dalam struktur bersarang ini.

Menghuraikan JSON dan Gelung Permulaan

Kod yang disediakan menggunakan pakej pengekodan/json untuk menghuraikan input JSON ke dalam objek[rentetan]antara muka{} peta. Peta ini mewakili tahap teratas hierarki JSON. Menggunakan gelung julat`, ia berulang melalui pasangan nilai kunci peringkat pertama dalam peta.

for firstLvlkey, firstLvlValue := range m {
    // process first-level key and value...
}

Lelaran Melepasi Tahap Kedua: Penyesuaian

Dalam gelung peringkat pertama, kod tersebut berusaha untuk melelar ke atas objek JSON bersarang peringkat kedua, seperti innerJSON1 dan InnerJSON2. Untuk mencapai matlamat ini, nilai antara muka{} setiap kunci peringkat pertama mesti disemak dan diproses dengan sewajarnya.

Cara yang cekap untuk mengendalikan ini adalah melalui penegasan jenis, menggunakan suis jenis untuk menentukan jenis antara muka{ } nilai. Dengan memanggil fungsi parseMap atau parseArray secara rekursif untuk peta atau tatasusunan bersarang, kod itu boleh meneroka semua peringkat struktur JSON secara berulang.

func parseMap(aMap map[string]interface{}) {
    for key, val := range aMap {
        switch concreteVal := val.(type) {
            case map[string]interface{}:
                // Nested map
                fmt.Println(key)
                parseMap(val.(map[string]interface{}))
            case []interface{}:
                // Nested array
                fmt.Println(key)
                parseArray(val.([]interface{}))
            default:
                // Primitive value
                fmt.Println(key, ":", concreteVal)
        }
    }
}

func parseArray(anArray []interface{}) {
    for i, val := range anArray {
        switch concreteVal := val.(type) {
            case map[string]interface{}:
                // Nested map
                fmt.Println("Index:", i)
                parseMap(val.(map[string]interface{}))
            case []interface{}:
                // Nested array
                fmt.Println("Index:", i)
                parseArray(val.([]interface{}))
            default:
                // Primitive value
                fmt.Println("Index", i, ":", concreteVal)
        }
    }
}

Output Contoh

Berdasarkan pada input JSON yang disediakan, kod akan mencetak pasangan nilai kunci dari tahap kedua bersarang:

InnerInnerJSONArray
Index: 0
fld1 : val1
Index: 1
fld2 : val2
value1 : 10
value2 : 22
InnerInnerArray
Index 0 : test1
Index 1 : test2
InnerJSON2 : NoneValue

Pertimbangan Tambahan

• Kod yang disediakan menganggap bahawa struktur JSON terbentuk dengan baik dan tidak mengendalikan input JSON yang tidak sah.
• Penggunaan pantulan jenis (antara muka{}) boleh menambah overhed pada atur cara berbanding dengan menggunakan struct ditaip untuk diketahui Struktur JSON.
• Untuk struktur JSON yang lebih kompleks atau pengoptimuman prestasi, pertimbangkan untuk menggunakan json.Decoder Go dan menavigasi hierarki JSON secara manual.

Atas ialah kandungan terperinci Bagaimana untuk Cekap Berulang Melalui JSON Bersarang Tahap Kedua dalam Go?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!