Comment analyser le format json dans Golang

La colonne suivante du tutoriel golang vous présentera la méthode d'analyse du format json en golang. J'espère qu'elle sera utile aux amis dans le besoin !

La partie des données interactives entre le client et le serveur dans le projet est json, elle doit donc être analysée côté serveur. Il est en fait assez laborieux d'analyser du json complexe.
Les données interactives sont similaires au format suivant :

{"sn":1,"ls":false,"bg":0,"ed":0,"ws":[{"bg":0,"cw":[{"sc":0,"w":"还"}]},{"bg":0,"cw":[{"sc":0,"w":"有点"}]},{"bg":0,"cw":[{"sc":0,"w":"眼熟"}]}]}

Vous devez supprimer le champ w au format json et l'épeler dans une chaîne de résultat pour l'afficher

• Obtenez ws à partir du tableau json
• ws est un tableau, l'élément du tableau est un objet
• cw est un tableau, l'élément du tableau est un objet
• w est une chaîne
• Récupérez le champ w à partir de cw traversal

L'implémentation préliminaire est la suivante :

func RecResultJsonToPlain() {    var recResult string    var dat map[string]interface{}
    json.Unmarshal([]byte(json_str), &dat)    if v, ok := dat["ws"]; ok {
        ws := v.([]interface{})        for i, wsItem := range ws {
            wsMap := wsItem.(map[string]interface{})            if vCw, ok := wsMap["cw"]; ok {
                cw := vCw.([]interface{})                for i, cwItem := range cw {
                    cwItemMap := cwItem.(map[string]interface{})                    if w, ok := cwItemMap["w"]; ok {
                        recResult = recResult + w.(string)
                    }
                }
            }
        }
    }
    fmt.Println(recResult)
}

De cette façon, il est un peu gênant de convertir les types couche par couche, puis obtenir des éléments. Puisqu'il s'agit d'une structure de données JSON connue, vous pouvez définir la structure puis l'analyser.

type CWItem struct {
    SC int32  `json:"sc"`
    W  string `json:"w"`}type WSItem struct {
    CW []CWItem}type IatResult struct {
    SN int32    `json:"sn"`
    LS bool     `json:"ls"`
    BG int32    `json:"bg"`
    ED int32    `json:"ed"`
    WS []WSItem `json:"ws"`}

Notez que la première lettre du nom de la variable doit être en majuscule lorsque est défini. Vous pouvez également utiliser des outils pour générer automatiquement des définitions https://mholt.github.io. /json-to -go/; L'outil généré est très beau :

type AutoGenerated struct {
    Sn int `json:"sn"`
    Ls bool `json:"ls"`
    Bg int `json:"bg"`
    Ed int `json:"ed"`
    Ws []struct {
        Bg int `json:"bg"`
        Cw []struct {
            Sc int `json:"sc"`
            W string `json:"w"`
        } `json:"cw"`
    } `json:"ws"`
}

func RecResultJsonToPlain(jsonResult []byte)(recPlainResult string)  {    var r IatResult
    json.Unmarshal(jsonResult, &r)    for _, wsItem := range r.WS {        for _, cwItem := range wsItem.CW {
            recPlainResult = recPlainResult + cwItem.W
        }
    }    return recPlainResult
}

Les éléments ci-dessus ont json:"sn" descriptions obligatoires, donc si vous n'avez besoin que d'obtenir les éléments correspondants, vous pouvez laissez les autres éléments indéfinis. Un autre type de données est que les éléments du tableau sont toujours des tableaux et que le tableau final contient des types de nombres ou de chaînes. Vous devez réécrire une fonction. Les données sont les suivantes : obtenez les éléments dans [21,1]

.

{"Asks": [[21, 1], [22, 1]] ,"Bids": [[20, 1], [19, 1]]}

Recherchez un morceau de code comme suit, réimplémentant UnmarshalJSON

package mainimport (    "encoding/json"    "fmt")type Message struct {
    Asks []Order `json:"Bids"`
    Bids []Order `json:"Asks"`}type Order struct {
    Price  float64
    Volume float64}func (o *Order) UnmarshalJSON(data []byte) error {    var v [2]float64    if err := json.Unmarshal(data, &v); err != nil {        return err    }
    o.Price = v[0]
    o.Volume = v[1]    return nil}func main() {
    b := []byte(`{"Asks": [[21, 1], [22, 1]] ,"Bids": [[20, 1], [19, 1]]}`)    var m Message    if err := json.Unmarshal(b, &m); err != nil {
        fmt.Println(err)        return    }
    fmt.Printf("%#v\n", m)}

Pour plus d'articles techniques sur Golang, veuillez visiter la colonne go langage !

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!