Wie entmarshaliere ich ein Go-Array mit unterschiedlichen Datentypen?

Unmarshalling eines Arrays unterschiedlicher Typen in Go

Beim Umgang mit Schlüssel-Wert-Paaren ist das Unmarshalling unkompliziert. Allerdings ist es eine Herausforderung, eine Reihe gemischter Typen in einer bestimmten Reihenfolge aufzulösen. Um dieses Problem zu lösen, ist eine Lösung erforderlich, die flexibel auf unterschiedliche Datentypen reagieren kann.

Die Programmiersprache Go bietet eine elegante Option zur Bewältigung dieses Szenarios. Durch die Nutzung des Schnittstellentyps {} in Verbindung mit der Typzusicherung können wir den zugrunde liegenden Typ jedes Array-Elements dynamisch analysieren und entsprechend entmarshalieren.

Lassen Sie uns den problematischen Code noch einmal betrachten und ihn ändern, um diese Technik zu nutzen:

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

Dieser modifizierte Code verwendet die Funktion decodeJSON, um die JSON-Struktur rekursiv zu analysieren, den Datentyp jedes Elements zu identifizieren und die entsprechende Darstellung zu drucken. Für komplexe verschachtelte Strukturen werden verschachtelte Aufrufe von decodeJSON ausgeführt.

Die von diesem überarbeiteten Code generierte Ausgabe zeigt, wie jedes Element basierend auf seinem Datentyp korrekt identifiziert und gedruckt wird:

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"

Mit Dank dieses verbesserten Verständnisses der Typverarbeitung in Go können Sie Arrays mit einer heterogenen Mischung von Datentypen sicher entmarshamlingieren und so eine genaue und konsistente Datendarstellung in Ihren Anwendungen sicherstellen.

Das obige ist der detaillierte Inhalt vonWie entmarshaliere ich ein Go-Array mit unterschiedlichen Datentypen?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!