Wie kann ich JSON in Go ohne redundantes Unmarshaling effizient analysieren?

JSON ohne redundantes Unmarshaling in Go analysieren

Beim Umgang mit JSON-Nachrichten, die unterschiedliche Datentypen enthalten, kann ein gängiger Ansatz das Unmarshaling der Daten in einer generischen Karte umfassen[ string]interface{}, um den Schlüssel zu überprüfen und zu versuchen, den Wert in bestimmte Strukturen umzuwandeln. Dieser Ansatz kann jedoch zu unnötigem doppeltem Unmarshaling führen.

Im Kontext von Go gibt es eine effizientere Lösung, die JSON-Daten teilweise in eine json.RawMessage statt in eine Schnittstelle{} zu entmarshalieren. Dies wird erreicht, indem die Karte wie folgt deklariert wird:

var myMap map[string]json.RawMessage

Wenn es darum geht, die Werte in bestimmte Strukturen umzuwandeln, kann der Marshalling-/Unmarshaling-Schritt entfallen. In Ihrem Fall haben Sie beispielsweise Folgendes in Ihre „Ack“-Struktur umgewandelt:

ackjson, err := json.Marshal(v)
if err != nil {
    fmt.Println("marshal error: ", err)
}
err = json.Unmarshal(ackjson, &myAck)
if err != nil {
    fmt.Println("unmarshal error", err)
}

Stattdessen kann es wie folgt vereinfacht werden:

err = json.Unmarshal(v, &myAck)

Dieser Ansatz vermeidet das redundante Unmarshaling Schritt, wodurch das Parsen effizienter wird.

Hier ist eine aktualisierte Version Ihres Codes, die dies berücksichtigt Optimierung:

package main

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

Durch die Verwendung von json.RawMessage und die Eliminierung unnötiger Unmarshaling können Sie die Leistung Ihres JSON-Parsings verbessern, ohne die Funktionalität zu beeinträchtigen.

Das obige ist der detaillierte Inhalt vonWie kann ich JSON in Go ohne redundantes Unmarshaling effizient analysieren?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!