Wie kann json.RawMessage beim Umgang mit heterogenen JSON-Strukturen doppeltes Unmarshaling in Go verhindern?

Mit RawMessage doppeltes Unmarshaling in Go vermeiden

In Go ist es bei der Arbeit mit JSON-Daten manchmal erforderlich, die Daten teilweise zu entmarshalieren, um auf unbekannte Felder zuzugreifen oder heterogene JSON-Strukturen verarbeiten. Allerdings kann dieser Prozess zu einem doppelten Unmarshaling führen, was ineffizient sein kann. In diesem Artikel wird eine Lösung zur Vermeidung dieses Problems mithilfe von json.RawMessage vorgestellt.

Stellen Sie sich ein Szenario vor, in dem eine Web-Socket-Verbindung verschiedene Arten von JSON-Nachrichten sendet und Sie diese in bekannte Strukturen entmarshalieren möchten. Der traditionelle Ansatz besteht darin, den JSON in ein generisches Map[string]interface{} zu entmarshalieren, nach dem gewünschten Schlüssel zu suchen und dann zu versuchen, den Wert in den gewünschten Typ umzuwandeln. Dieser Ansatz kann jedoch fehlschlagen, wenn mit verschachtelten JSON-Strukturen gearbeitet wird.

Um dieses Problem zu lösen, können wir die Werte nicht in interface{}, sondern in json.RawMessage entmarshalieren. Dadurch können wir auf die JSON-Rohdaten zugreifen, ohne die Typinformationen zu verlieren. Später können wir in der Switch-Anweisung die JSON-Rohdaten direkt in die gewünschte Struktur entmarshallen, ohne sie erneut marshalieren zu müssen.

import (
    "encoding/json"
    "fmt"
)

type Ping struct {
    Ping string `json:"ping"`
}

type Ack struct {
    Messages []Message `json:"messages"`
}

type Message string

func main() {
    testJSON := []byte(`{"ack":{"messages":["Hi there","Hi again"]}}`)
    var myAck = Ack{}
    var myMap map[string]json.RawMessage
    err := json.Unmarshal(testJSON, &myMap)
    if err != nil {
        fmt.Println("error unmarshalling: ", err)
    }

    for k, v := range myMap {
        fmt.Printf("key: %s, value: %s \n", k, v)

        switch k {
        case "ping":
            fmt.Println(k, " is a ping", v)
        case "ack":
            fmt.Println(k, " is an ack containing a message list")
            err = json.Unmarshal(v, &myAck)
            if err != nil {
                fmt.Println("unmarshal error", err)
            } else {
                fmt.Println("New ack object: ", myAck)
            }
        default:
            fmt.Printf("%s is of a type (%T) I don't know how to handle", k, v)
        }
    }
}

Mit diesem Ansatz vermeiden wir den redundanten Schritt des Marshallings und Unmarshallings die JSON-Daten, was den Umgang mit JSON-Daten mit heterogenen Strukturen effizienter und einfacher macht.

Das obige ist der detaillierte Inhalt vonWie kann json.RawMessage beim Umgang mit heterogenen JSON-Strukturen doppeltes Unmarshaling in Go verhindern?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!