unmarshalling una matriz de tipos diversos

en el manejo de JSON, las matrices de solteros con tipos de elementos variados pueden ser desafiantes. Este artículo aborda la cuestión de las matrices de soltero que consisten en elementos con tipos de datos conocidos pero no organizados.

Go función. Al usar la afirmación de tipo, el tipo de datos se puede determinar dinámicamente.

adaptando su código

la siguiente versión modificada de su código muestra este enfoque:

principal de paquete de paquete importar ( "Codificación/JSON" "FMT" ) var my_json string = `{ "an_array": [ "Cadena con una cadena", { "y": "some_more", "diferente": ["anidado", "tipos"] } ] } ` Func IdentionDatatyPes (interfaz F {}) { cambiar vf: = f. (tipo) { Interfaz MAP [String] MAP [String] {}: fmt.println ("es un mapa:") para k, v: = rango vf { cambiar vv: = v. (tipo) { Cadena de casos: fmt.printf (" %v: es cadena - %q \ n", k, vv) Caso int: fmt.printf (" %v: int - %q \ n", k, vv) por defecto: fmt.printf ("%v:", k) IdentionDatatypes (V) } } Case [] interfaz {}: fmt.println ("es una matriz:") para k, v: = rango vf { cambiar vv: = v. (tipo) { Cadena de casos: fmt.printf (" %v: es cadena - %q \ n", k, vv) Caso int: fmt.printf (" %v: int - %q \ n", k, vv) por defecto: fmt.printf ("%v:", k) IdentionDatatypes (V) } } } } func Main () { fmt.println ("json: \ n", my_json, "\ n") interfaz var f {} err: = json.unmarshal ([] byte (my_json), & f) si err! = nil { fmt.println (err) } demás { fmt.printf ("json:") Identificar Datatypes (F) } }

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

El código produce la siguiente salida:

json: { "an_array": [ "Cadena con una cadena", { "y": "some_more", "diferente": ["anidado", "tipos"] } ] } JSON: es un mapa: an_array: es una matriz: 0: es cadena - "con cadena con_a" 1: es un mapa: y: es cadena - "some_more" Diferente: es una matriz: 0: es una cadena - "anidada" 1: es cadena - "tipos"

Este enfoque permite la identificación dinámica y el manejo de los tipos de elementos dentro de la matriz, proporcionando una solución versátil para sus necesidades solteras.