Bagaimanakah Saya Boleh Menyahmarshal Tatasusunan JSON dengan Jenis Data Campuran dalam Go?

Menyahmarshall Array of Diverse Type

Dalam pengendalian JSON, unmarshalling array dengan pelbagai jenis elemen boleh mencabar. Artikel ini menangani isu tatasusunan unmarshalling yang terdiri daripada elemen dengan jenis data yang diketahui tetapi tidak diisih.

Kaedah Go untuk Penyahkodan Data Arbitrari

Seperti yang digariskan dalam dokumentasi rasmi Go tentang JSON pengekodan, adalah mungkin untuk menyahkod data sewenang-wenang ke dalam antara muka{} menggunakan fungsi json.Unmarshal. Dengan menggunakan penegasan jenis, jenis data boleh ditentukan secara dinamik.

Menyesuaikan Kod Anda

Versi kod anda yang diubah suai berikut mempamerkan pendekatan ini:

package main

import (
    "encoding/json"
    "fmt"
)

var my_json string = `{
    "an_array":[
    "with_a string",
    {
        "and":"some_more",
        "different":["nested", "types"]
    }
    ]
}`

func IdentifyDataTypes(f interface{}) {
    switch vf := f.(type) {
    case map[string]interface{}:
        fmt.Println("is a map:")
        for k, v := range vf {
            switch vv := v.(type) {
            case string:
                fmt.Printf("%v: is string - %q\n", k, vv)
            case int:
                fmt.Printf("%v: is int - %q\n", k, vv)
            default:
                fmt.Printf("%v: ", k)
                IdentifyDataTypes(v)
            }

        }
    case []interface{}:
        fmt.Println("is an array:")
        for k, v := range vf {
            switch vv := v.(type) {
            case string:
                fmt.Printf("%v: is string - %q\n", k, vv)
            case int:
                fmt.Printf("%v: is int - %q\n", k, vv)
            default:
                fmt.Printf("%v: ", k)
                IdentifyDataTypes(v)
            }

        }
    }
}

func main() {

    fmt.Println("JSON:\n", my_json, "\n")

    var f interface{}
    err := json.Unmarshal([]byte(my_json), &f)
    if err != nil {
        fmt.Println(err)
    } else {
        fmt.Printf("JSON: ")
        IdentifyDataTypes(f)
    }
}

Output

Kod menghasilkan yang berikut output:

JSON:
 {
    "an_array":[
    "with_a string",
    {
        "and":"some_more",
        "different":["nested", "types"]
    }
    ]
}

JSON: is a map:
an_array: is an array:
0: is string - "with_a string"
1: is a map:
and: is string - "some_more"
different: is an array:
0: is string - "nested"
1: is string - "types"

Pendekatan ini membolehkan pengecaman dinamik dan pengendalian jenis elemen dalam tatasusunan, menyediakan penyelesaian serba boleh untuk keperluan anda yang tidak tersusun.

Atas ialah kandungan terperinci Bagaimanakah Saya Boleh Menyahmarshal Tatasusunan JSON dengan Jenis Data Campuran dalam Go?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!