Wie kann man verschachteltes JSON mit unbekannter Struktur effizient entmarshallen?

Unmarshalling von verschachteltem JSON mit unbekannter Struktur

In diesem Szenario haben wir es mit JSON-Daten mit einer unbekannten Struktur zu tun, die in einem Schlüsselwert gespeichert sind speichern. Beim Abrufen von Einträgen aus der Datenbank führen wir zunächst ein Unmarshaling in eine Map[string]*json.RawMessage durch, um den Namespace der obersten Ebene zu verarbeiten. Um die verschachtelten Daten jedoch weiter zu entpacken, müssen wir die spezifische zu verwendende Struktur bestimmen.

1. Vermeiden wiederholter Unmarshals:

Wiederholte Unmarshals können möglicherweise die Leistung beeinträchtigen. Abhängig von der Datenstruktur und den Zugriffsmustern kann dies jedoch erforderlich sein. Wenn die Unmarshalling-Geschwindigkeit von entscheidender Bedeutung ist, sollten Sie erwägen, die Unmarshalling-Ergebnisse zwischenzuspeichern.

2. Bestimmen des Strukturtyps:

Methode A: Unmarshalieren zur Schnittstelle

• Unmarshalieren der json.RawMessage zu einer Map[string]-Schnittstelle{}.
• Überprüfen Sie den Wert, der dem Schlüssel „type“ zugeordnet ist.
• Verwenden Sie eine Switch-Anweisung oder Reflexion, um die richtige Struktur zu bestimmen.

Methode B: Regulär Ausdruck

• Verwenden Sie einen regulären Ausdruck, um die „Typ“-Zeichenfolge aus den JSON-Daten zu extrahieren.
• Erstellen Sie eine Karte von Strukturtypen, die den möglichen „Typ“-Zeichenfolgen zugeordnet sind.
• Entpacken Sie die json.RawMessage in die entsprechende Struktur.

Beispiel:

Methode A:

<code class="go">type RawData struct {
    Id       string `json:"id"`
    Type      string `json:"type"`
    RawData   []int  `json:"rawdata"`
    Epoch     string `json:"epoch"`
}

// Unmarshal to interface
data := make(map[string]interface{})
json.Unmarshal(*objmap["foo"], &amp;data)

// Determine struct type
switch data["type"] {
case "baz":
    baz := &amp;RawData{}
    json.Unmarshal(*objmap["foo"], baz)
case "bar":
    bar := &amp;BarData{}
    json.Unmarshal(*objmap["foo"], bar)
}

// Custom struct for nested data
type BarData struct {
    Id       string `json:"id"`
    Type      string `json:"type"`
    RawData   []QuxData  `json:"rawdata"`
    Epoch     string `json:"epoch"`
}

type QuxData struct{
    Key string `json:"key"`
    Values []int `json:"values`
}</code>

Methode B:

<code class="go">// Regular expression to extract type
typeRegex := regexp.MustCompile(`"type": "(.+?)"`)

// Get "type" string
typeString := string(typeRegex.Find(*objmap["foo"]))

// Map of struct types
structMap := map[string]interface{}{
    "baz": &amp;RawData{},
    "bar": &amp;BarData{},
}

// Unmarshal to corresponding struct
dataStruct := structMap[typeString]
json.Unmarshal(*objmap["foo"], dataStruct)</code>

Durch die Implementierung einer dieser Methoden können Sie die richtige Struktur bestimmen, in die die json.RawMessage entmarshaliert werden soll, damit Sie darauf zugreifen können die verschachtelten Daten effizient verarbeiten.

Das obige ist der detaillierte Inhalt vonWie kann man verschachteltes JSON mit unbekannter Struktur effizient entmarshallen?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!