unmarshalling una matriz de tipos dispares en Go

al manejar pares de valores clave, la unmarshalling es sencilla. Sin embargo, la desamparación de una variedad de tipos mixtos en un orden distinto presenta un desafío. La resolución de este problema exige una solución que pueda acomodar diferentes tipos de datos de manera flexible.

El lenguaje de programación GO proporciona una opción elegante para manejar este escenario. Al aprovechar el tipo de interfaz {} en conjunto con la afirmación de tipo, podemos analizar dinámicamente el tipo subyacente de cada elemento de matriz y unmarshal en consecuencia.

volvamos a visitar el código problemático y modificarlo para aprovechar esta técnica:

package main

import (
    "encoding/json"
    "fmt"
)

func decodeJSON(f interface{}) {
    switch vf := f.(type) {
    case map[string]interface{}:
        fmt.Println("is a map:")
        for k, v := range vf {
            checkTypeAndDecode(k, v)
        }
    case []interface{}:
        fmt.Println("is an array:")
        for k, v := range vf {
            checkTypeAndDecode(k, v)
        }
    }
}

func checkTypeAndDecode(k string, v interface{}) {
    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)
        decodeJSON(v)
    }
}

func main() {
    my_json := `{
    "an_array":[
    "with_a string",
    {
        "and":"some_more",
        "different":["nested", "types"]
    }
    ]
}`

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

Este código modificado emplea la función DecodeJson para analizar recursivamente la estructura JSON, identificando el tipo de datos de cada elemento e imprimiendo la representación apropiada. Para estructuras anidadas complejas, se realizan llamadas anidadas a DecodeJson.

La salida generada por este código revisado ilustra cómo cada elemento se identifica e imprime correctamente en función de su tipo de datos:

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"

Con esta comprensión mejorada del manejo de tipos en GO, puede con confianza matrices de soltera que contienen una combinación heterogénea de tipos de datos, asegurando una representación de datos precisa y consistente en sus aplicaciones.