Question

如何解析这个json

[
  [
    [
      "Odio los lunes",
      "i hate mondays",
      null,
      null,
      1
    ]
  ],
  null,
  "en"
]

只显示Odio los lunes？

Answer 1

实现unmarshalar以获取嵌套数组所需的值，并使用unmarshal将其解析为struct并使用：

package main

import (
    "fmt"
    "encoding/json"
)

func(item *Result) UnmarshalJSON(data []byte)error{
    var v []interface{}
    if err:= json.Unmarshal(data, &v);err!=nil{
        fmt.Println(err)
        return err
    }
    item.Data = v[0].(interface{}).([]interface{})[0].([]interface{})[0].(string)
    return nil
}

type Result struct {
    Data string
}

func main() {
    var result Result
    jsonString := []byte(`[[["Odio los lunes", "i hate mondays", null, null, 1]], null, "en"]`)
    if err := json.Unmarshal(jsonString, &result); err != nil{
        fmt.Println(err)
    }
    //fmt.Printf("%+v\n",result)
    value := result.Data
    fmt.Println(value)
}

Playground example

Answer 2

一种简单的方法是将JSON文档解析为interface{}（“任何类型”），并通过断言解析的结构来获取目标字符串值。例如(on the go playground)：

func main() {
  str := GetTargetString([]byte(jsonstr))
  fmt.Println(str) // => "Odio los lunes"
}

func GetTargetString(bs []byte) string {
  var doc interface{}
  if err := json.Unmarshal(bs, &doc); err != nil {
    panic(err)
  }
  return doc.([]interface{})[0].([]interface{})[0].([]interface{})[0].(string)
}

如果给定的字节切片不包含有效的JSON文档，或者文档的结构不够相似（即，第一个元素是数组的数组，其第一个元素），则“GetTargetString”函数将发生混乱是一个数组，其第一个元素是一个字符串）。

更惯用（通常更安全）的方法是使用类型断言的特殊双返回值形式检查类型并返回(string, error)的元组，例如：

if err := json.Unmarshal(jsonString, &result); err != nil {
  return "", err
}

array0, ok := doc.([]interface{})
if !ok {
  return "", fmt.Errorf("JSON document is not an array")
}

array1, ok := array0[0].([]interface{})
if !ok {
  return "", fmt.Errorf("first element is not an array")
}

// ...

Answer 3

fastjson：

更简单（更快）

var p fastjson.Parser
v, err := p.Parse(input)
if err != nil {
    log.Fatal(err)
}
fmt.Printf("v[0][0][0]: %s", v.GetStringBytes("0", "0", "0"))

在golang中解析变量中的Json

3 个答案: