Bagaimana untuk Cekap Berulang Melalui JSON Bersarang dalam Go?

Menggelung/Membalas Melepasi JSON Bersarang Tahap Kedua dalam Go Lang

Pertimbangkan senario di mana anda menghadapi struktur JSON bersarang seperti yang digambarkan di bawah:

{
    "outterJSON": {
        "innerJSON1": {
            "value1": 10,
            "value2": 22,
            "InnerInnerArray": [ "test1" , "test2"],
            "InnerInnerJSONArray": [ {"fld1" : "val1"} , {"fld2" : "val2"} ]
        },
        "InnerJSON2":"NoneValue"
    }
}

Tugasnya adalah untuk melelaran secara berkesan melalui struktur ini dan mendapatkan semula semua pasangan nilai kunci sebagai rentetan untuk pemprosesan selanjutnya. Malangnya, mentakrifkan struktur secara manual untuk input JSON dinamik sedemikian tidak boleh dilaksanakan.

Pendekatan Lelaran Cekap

Untuk menavigasi cabaran ini dengan cekap, pendekatan rekursif digunakan:

func parseMap(m map[string]interface{}) {
  for key, val := range m {
    // Check the type of the value
    switch concreteVal := val.(type) {
      case map[string]interface{}:
        // If it's a nested map, recursively call the function
        parseMap(val.(map[string]interface{}))
      case []interface{}:
        // If it's a nested array, call the function to parse the array
        parseArray(val.([]interface{}))
      default:
        // For all other types, print the key and value as a string
        fmt.Println(key, ":", concreteVal)
    }
  }
}

Fungsi rekursif parseMap ini mengkaji jenis setiap nilai dalam peta. Jika nilai itu sendiri adalah peta, ia secara rekursif memanggil parseMap untuk melintasi peta bersarang itu. Jika nilainya ialah tatasusunan, ia memanggil parseArray untuk mengulanginya. Untuk semua jenis lain (seperti rentetan, nombor, dll.), ia hanya mencetak kunci dan nilai sebagai rentetan.

Demo

Pertimbangkan contoh input JSON yang disediakan sebelum ini. Menjalankan kod di bawah akan menghasilkan output berikut:

func parseArray(a []interface{}) {
  for i, val := range a {
    // Check the type of the value
    switch concreteVal := val.(type) {
      case map[string]interface{}:
        // If it's a nested map, recursively call the function
        parseMap(val.(map[string]interface{}))
      case []interface{}:
        // If it's a nested array, call the function to parse the array
        parseArray(val.([]interface{}))
      default:
        // For all other types, print the index and value as a string
        fmt.Println("Index:", i, ":", concreteVal)
    }
  }
}

const input = `
{
    "outterJSON": {
        "innerJSON1": {
            "value1": 10,
            "value2": 22,
            "InnerInnerArray": [ "test1" , "test2"],
            "InnerInnerJSONArray": [{"fld1" : "val1"} , {"fld2" : "val2"}]
        },
        "InnerJSON2":"NoneValue"
    }
}
`

Output:

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

Pendekatan ini secara berkesan menangkap semua pasangan nilai kunci dalam JSON bersarang, menjadikannya sesuai untuk pemprosesan dan tugas pengekstrakan dalam Go lang.

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