Heim > Backend-Entwicklung > Golang > Wie kann ich ein JSON-Array mit gemischten Datentypen in Go entmarshalieren?

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

Barbara Streisand
Freigeben: 2024-12-14 05:00:09
Original
354 Leute haben es durchsucht

How Can I Unmarshal a JSON Array with Mixed Data Types in Go?

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)
    }
}
Nach dem Login kopieren

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"
Nach dem Login kopieren

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!

Quelle:php.cn
Erklärung dieser Website
Der Inhalt dieses Artikels wird freiwillig von Internetnutzern beigesteuert und das Urheberrecht liegt beim ursprünglichen Autor. Diese Website übernimmt keine entsprechende rechtliche Verantwortung. Wenn Sie Inhalte finden, bei denen der Verdacht eines Plagiats oder einer Rechtsverletzung besteht, wenden Sie sich bitte an admin@php.cn
Neueste Artikel des Autors
Beliebte Tutorials
Mehr>
Neueste Downloads
Mehr>
Web-Effekte
Quellcode der Website
Website-Materialien
Frontend-Vorlage