marrshalling ein Array von unterschiedlichen Typen in Go

Bei der Behandlung von Schlüsselwertpaaren sind Unmarshalling direkt. Wenn Sie jedoch eine Reihe von gemischten Typen in einer bestimmten Reihenfolge nicht streichen, stellt es jedoch eine Herausforderung dar. Durch die Lösung dieses Problems erfordert eine Lösung, die unterschiedliche Datentypen auf flexible Weise berücksichtigen kann.

Die Go -Programmiersprache bietet eine elegante Option für die Behandlung dieses Szenarios. Durch die Nutzung der Schnittstelle {} Typ in Verbindung mit der Typ -Behauptung können wir den zugrunde liegenden Typ jedes Array -Elements dynamisch analysieren und entsprechend unmarshal. importieren ( "Codierung/JSON" "fmt" ) func decodejson (f interface {}) { Schalter VF: = f. (Typ) { Fallkarte [String] Schnittstelle {}: fmt.println ("ist eine Karte:") für k, v: = Bereich vf { ygetePeanddecode (k, v) } case [] Schnittstelle {}: fmt.println ("ist ein Array:") für k, v: = Bereich vf { ygetePeanddecode (k, v) } } } func checkTypeAnDeCode (k String, v -Schnittstelle {}) { Schalter VV: = v. (Typ) { Fallzeichenfolge: fmt.printf (" %v: ist String - %Q \ n", K, VV) Fall int: fmt.printf (" %v: ist int - %q \ n", k, vv) Standard: fmt.printf ("%v:", k) decodejson (v) } } func main () { my_json: = `{ "an_array": [ "With_a String", { "und": "seltsamer", "anders": ["verschachtelt", "Typen"] } ] } ` var f interface {} err: = json.unmarshal ([] byte (my_json), & f) Wenn er! = nil { fmt.println (err) } anders { fmt.println ("json:") decodejson (f) } }

Dieser geänderte Code verwendet die Decodejson -Funktion, 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 bei Decodejson durchgeführt.

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

JSON: ist eine Karte: an_array: Ist ein Array: 0: ist String - "mit _a String" 1: Ist eine Karte: und: ist String - "slow_more" anders: Ist ein Array: 0: ist String - "verschachtelt" 1: IS String - "Typen"

Mit diesem erweiterten Verständnis des Typs Handhabung in GO können Sie zuversichtlich unmarshal -Arrays, die eine heterogene Mischung von Datentypen enthalten, zuversichtlich und eine genaue und konsistente Datendarstellung in Ihren Anwendungen sicherstellen.