Comment désorganiser efficacement le JSON imbriqué avec une structure inconnue ?

Désorganisation du JSON imbriqué avec une structure inconnue

Dans ce scénario, nous avons affaire à des données JSON avec une structure inconnue stockées dans une clé-valeur magasin. Lors de la récupération des entrées de la base de données, nous les désorganisons initialement dans un map[string]*json.RawMessage pour gérer l'espace de noms de niveau supérieur. Cependant, pour mieux désorganiser les données imbriquées, nous devons déterminer la structure spécifique à utiliser.

1. Éviter les démarshals répétés :

Les démarshals répétés peuvent potentiellement affecter les performances. Cependant, cela peut être nécessaire en fonction de la structure des données et des modèles d'accès. Si la vitesse de désorganisation est essentielle, envisagez de mettre en cache les résultats non organisés.

2. Détermination du type de structure :

Méthode A : désassembler vers l'interface

• Désassembler le json.RawMessage vers une interface map[string]{}.
• Vérifiez la valeur associée à la clé "type".
• Utilisez une instruction switch ou une réflexion pour déterminer la structure correcte.

Méthode B : Régulière Expression

• Utilisez une expression régulière pour extraire la chaîne "type" des données JSON.
• Créez une carte des types de structures associés aux chaînes "type" possibles.
• Désorganisez le json.RawMessage dans la structure correspondante.

Exemple :

Méthode 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>

Méthode 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>

En implémentant l'une ou l'autre de ces méthodes, vous pouvez déterminer la structure correcte dans laquelle désorganiser le json.RawMessage, vous permettant d'accéder les données imbriquées efficacement.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!