Wie kann man verschachtelte JSON-Daten entmarshalieren, ohne deren Struktur zu kennen?

Unmarshaling von verschachteltem JSON ohne Strukturkenntnisse

Problemstellung

Beim Umgang mit verschachtelten JSON-Daten , kann es schwierig sein, die geeignete Struktur für das Unmarshalling zu bestimmen. Dies gilt insbesondere für Daten, die in einem Schlüsselwertspeicher gespeichert sind, wo die Struktur der JSON-Daten stark variieren kann.

Frage 1: Wiederholtes Unmarshaling vermeiden

While Wiederholtes Unmarshaling kann zu einem gewissen Leistungsaufwand führen. Dies ist nicht unbedingt zu vermeiden, es sei denn, es stellt einen erheblichen Engpass dar.

Frage 2: Bestimmen des Strukturtyps

Es gibt zwei Hauptmethoden zur Bestimmung des Strukturtyps:

Methode 1: Unmarshaling zu einer Schnittstelle

1. Unmarshaling der json.RawMessage zu einer Map[string]-Schnittstelle{} mit json.Unmarshal(*objmap["foo"], &myMap).
2. Überprüfen Sie den Typ der verschachtelten JSON-Daten in myMap. Es wird der tatsächliche Typ der Daten angezeigt (z. B. Baz, Bar).

Methode 2: Verwendung regulärer Ausdrücke

1. Erstellen Sie einen regulären Ausdruck, um das Typfeld aus den verschachtelten JSON-Daten zu extrahieren.
2. Verwenden Sie die Funktion regexp.FindString, um den Typ zu extrahieren.

Sobald der Strukturtyp bestimmt ist, können Sie ihn entmarshalieren Daten:

varbazorbar interface{}
if err := json.Unmarshal(*objmap["foo"], &bazorbar); err !=nil{
   return err
}

switch v := bazorbar.(type) {
case map[string]*json.RawMessage:
   // If the data is a nested JSON object, further unmarshaling is needed.
   result, err := unmarshalNested(v["nested_data"])
   if err != nil
      return err
   foo.Nested_Data = result
case []interface{}:
   // If the data is an array of JSON objects, process each element.
   for _, item := range v {
      result, err := unmarshalNested(item.(map[string]interface{}))
      if err != nil
         return err
      foo.Nested_Array = append(foo.Nested_Array, result)
   }
}

Beispielcode:

// Unmarshals nested JSON data.
func unmarshalNested(data map[string]interface{}) (interface{}, error) {
   type_expr := regexp.MustCompile(`"type":\s*"([a-zA-Z]+)"`)
   matches := type_expr.FindStringSubmatch(data["foo"].(string))

   if len(matches) == 2 {
      switch matches[1] {
         case "Baz":
            var baz Baz
            if err := json.Unmarshal([]byte(data["foo"].(string)), &baz); err != nil {
               return nil, err
            }
            return baz, nil
         case "Bar":
            var bar Bar
            if err := json.Unmarshal([]byte(data["foo"].(string)), &bar); err != nil {
               return nil, err
            }
            return bar, nil
      }
   }
   return nil, errors.New("cannot determine type")
}

Das obige ist der detaillierte Inhalt vonWie kann man verschachtelte JSON-Daten entmarshalieren, ohne deren Struktur zu kennen?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!