Wie kann ich ein JSON-Array mit gemischten Datentypen in Go entmarshalieren?

Unmarshalling eines Arrays verschiedener Typen

Bei der JSON-Verarbeitung kann das Unmarshalling von Arrays mit unterschiedlichen Elementtypen eine Herausforderung darstellen. Dieser Artikel befasst sich mit dem Problem des Unmarshallings von Arrays, die aus Elementen mit bekannten, aber unsortierten Datentypen bestehen.

Gos Methode zur willkürlichen Datendekodierung

Wie in der offiziellen Dokumentation von Go zu JSON beschrieben Codierung ist es möglich, beliebige Daten mithilfe der json.Unmarshal-Funktion in eine Schnittstelle{} zu dekodieren. Mithilfe der Typzusicherung kann der Datentyp dynamisch bestimmt werden.

Anpassen Ihres Codes

Die folgende modifizierte Version Ihres Codes veranschaulicht diesen Ansatz:

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

Ausgabe

Der Code erzeugt Folgendes Ausgabe:

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"

Dieser Ansatz ermöglicht die dynamische Identifizierung und Handhabung von Elementtypen innerhalb des Arrays und bietet eine vielseitige Lösung für Ihre Unmarshalling-Anforderungen.

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