Wie kann man verschachteltes JSON mit unbekannter Struktur effizient entmarshallen?

Mary-Kate Olsen
Freigeben: 2024-11-04 05:02:29
Original
351 Leute haben es durchsucht

How to Unmarshall Nested JSON with Unknown Structure Efficiently?

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"], &data)

// Determine struct type
switch data["type"] {
case "baz":
    baz := &RawData{}
    json.Unmarshal(*objmap["foo"], baz)
case "bar":
    bar := &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>
Nach dem Login kopieren

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": &RawData{},
    "bar": &BarData{},
}

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

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!

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
Über uns Haftungsausschluss Sitemap
Chinesische PHP-Website:Online-PHP-Schulung für das Gemeinwohl,Helfen Sie PHP-Lernenden, sich schnell weiterzuentwickeln!