Question

我有一个如下样本

result = [{"Key":"9802", "Record":{"action":"Warning","status":"Created","statusid":"9802","system":"CRM","thresholdtime":"9"}}]

我如何在Go lang中访问阈值时间值？

我正在尝试这样显示： result[0]["Record"]["thresholdtime"]

error:  invalid operation: result[0]["Record"] (type byte does not support indexing)

谢谢

Answer 1

我认为这样的事情应该会使您更接近：https://play.golang.org/p/ytpHTTNMjB-

使用内置的json包将数据解码为结构（带有附加的json标签）。然后，就像访问结构字段一样简单。

Answer 2

json.Unmarshal(...) Example应该让您入门。

这是一种实现方法（Go Playground）：

func main() {
  var krs []KeyRecord
  err := json.Unmarshal([]byte(jsonstr), &krs)
  if err != nil {
    panic(err)
  }

  fmt.Println(krs[0].Record.ThresholdTime)
  // 9
}

type KeyRecord struct {
  Key    int    `json:"Key,string"`
  Record Record `json:"Record"`
}

type Record struct {
  Action        string `json:"action"`
  Status        string `json:"status"`
  StatusId      int    `json:"statusid,string"`
  System        string `json:"system"`
  ThresholdTime int    `json:"thresholdtime,string"`
}

var jsonstr = `
[
  {
    "Key": "9802",
    "Record": {
      "action": "Warning",
      "status": "Created",
      "statusid": "9802",
      "system": "CRM",
      "thresholdtime": "9"
    }
  }
]
`

您可以将JSON文档解组为通用类型；但是，出于多种原因不建议这样做，最终会导致类型信息丢失：

xs := []map[string]interface{}{}
err := json.Unmarshal([]byte(jsonstr), &xs)
if err != nil {
    panic(err)
}

ttstr := xs[0]["Record"].(map[string]interface{})["thresholdtime"].(string)
fmt.Printf("%#v\n", ttstr) // Need to convert to int separately, if desired.
// "9"

Answer 3

使用json.Unmarshal将数据解组为合适的数据类型。在许多情况下，您可以（并且我建议）使用带有struct标签的自定义声明的json类型。

但是，对于您对另一个答案的评论，可以将其编组为interface{}，并让编组者确定最合适的数据类型来表示JSON结构。例如，[]interface{}类型的切片将代表一个列表，map[string]interface{}的映射将是字典，其等效JSON的原始类型，等等。

我上周编写了一个解析器，该解析器将这种方法用于另一个Stack问题。这并不是要成为高性能或经过高度测试的代码，而是要说明关键点：

package main

import (
    "encoding/json"
    "fmt"
    "log"
    "reflect"
    "strconv"
    "strings"
)

// Some arbitrary JSON
const js = `
{
  "key1": [
    {"key2": false, "some_other_key": "abc"},
    {"key3": 3}
  ],
  "key2": {
    "hello": "world"
  },
  "shallow": true,
  "null_value": null
}`

func indentStringLines(s string, n int) string {
    // Build indent whitespace - this has not been optimized!
    var indent string
    for i := 0; i < n; i++ {
        indent += " "
    }

    parts := strings.Split(s, "\n")
    for i := 0; i < len(parts) - 1; i++ {
        parts[i] = indent + parts[i]
    }
    return strings.Join(parts, "\n")
}

func recursivelyPrintSlice(m []interface{}, indent int) string {
    var str string
    for i, val := range m {
        str += fmt.Sprintf("%s: %s\n",
            strconv.FormatInt(int64(i), 10),
            recursivelyPrint(val, indent),
        )
    }
    return strings.TrimSpace(str)
}

func recursivelyPrint(val interface{}, indent int) string {
    var str string

    switch v := val.(type) {
    case bool:
        str += strconv.FormatBool(v)
    case float64:
        str += strconv.FormatFloat(v, 'g', -1, 64)
    case string:
        str += v
    case map[string]interface{}:
        str += "{\n"
        for key, childVal := range v {
            str += fmt.Sprintf("%s: %s\n", key, recursivelyPrint(childVal, indent))
        }
        str += "}"
    case []interface{}:
        str += "[\n" + recursivelyPrintSlice(v, indent) + "\n]"
    case nil:
        str += "null"
    default:
        str += fmt.Sprintf(
            "[unimplemented type printer for %s]",
            reflect.ValueOf(v).Kind(),
        )

    }
    return strings.TrimSpace(indentStringLines(str, indent+2))
}

func main() {
    var x interface{}
    err := json.Unmarshal([]byte(js), &x)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println(recursivelyPrint(x, 0))
}

如何在go lang中从json数组访问键和值

3 个答案: