无法将interface{}转换为字节：“interface{}是接口，而不是字节”

小伙伴们对Golang编程感兴趣吗？是否正在学习相关知识点？如果是，那么本文《无法将interface{}转换为字节：“interface{}是接口，而不是字节”》，就很适合你，本篇文章讲解的知识点主要包括。在之后的文章中也会多多分享相关知识点，希望对大家的知识积累有所帮助！

我正在解析大型 json 文件，我需要解析其子对象 items。

可以看到 items 的类型为 []interface{}:

我成功解析了第一个对象 map[]string]interface{} 但之后我尝试解析 pods["items"] ，它的类型为 []interface{} ，我将其转换为[]byte 用于 json.unmarshal 函数，但失败了：

interface {} 是 []interface []，而不是 []uint8

这是要重现的代码：

package main

import (
    "encoding/json"
    "fmt"
)

var mytest string = `
{
   "kind":"PodList",
   "apiVersion":"v1",
   "metadata":{
     
   },
   "items":[{
         "metadata":{
            "name":"super-user-pod5551",
            "namespace":"kube-system",
            "selfLink":"/api/v1/namespaces/kube-system/pods/super-user-pod5551",
            "uid":"fe9cf599-6e82-4a1b-8db5-5e319a58e1da"
         },
         "spec":{
            "volumes":[
               {
                  "name":"bootstrap-signer-token-dmp5q",
                  "secret":{
                     "secretName":"bootstrap-signer-token-dmp5q",
                     "defaultMode":420
                  }
               }
            ],
            "containers":[
               {
                  "name":"redis",
                  "image":"busybox:1.28",
                  "resources":{
                     
                  },
                  "volumeMounts":[
                     {
                        "name":"bootstrap-signer-token-dmp5q",
                        "readOnly":true,
                        "mountPath":"/var/run/secrets/kubernetes.io/serviceaccount"
                     }
                  ],
                  "terminationMessagePath":"/dev/termination-log",
                  "terminationMessagePolicy":"File",
                  "imagePullPolicy":"IfNotPresent",
                  "securityContext":{
                     "capabilities":{
                        "add":[
                           "SYS_TIME"
                        ]
                     }
                  }
               }
            ],
            "restartPolicy":"Always",
            "terminationGracePeriodSeconds":30,
            "schedulerName":"default-scheduler"
         },
         "status":{
            "phase":"Failed",
            "message":"The node was low on resource: ephemeral-storage. ",
            "reason":"Evicted",
            "startTime":"2020-05-10T11:13:33Z"
         }
      }
    ]
}
`


func main(){

    //var pods interface{}
    var pods map[string]interface{}
    err := json.Unmarshal([]byte(mytest), &pods)
    fmt.Println(err)
    //var spec map[string]interface{}
    //err = json.Unmarshal(byte(pods["items"]), &pods["items"])
    var items []interface{}

    err = json.Unmarshal(pods["items"].([]byte), &items)
    fmt.Println(err)

}

go演示链接。

解决方案

在阅读this博客中的“任意对象和数组”之后，我明白了如何做到这一点。

就像 @steven eckhoff 提到的，我需要将 map[string]interface{} 对象移动到变量，然后使用键和值运行它，我可以按每个值的类型检查每个值并迭代这些对象。

以下是主要代码和解决方案的示例：

func main(){

    var pods interface{}
    //var pods podlist
    err := json.unmarshal([]byte(mytest), &pods)

    if err != nil {
        log.fatal(err)
    }
    data := pods.(map[string]interface{})
    for k, v := range data {
        switch v := v.(type) {
        case string:
            fmt.println(k, v, "(string)")
        case float64:
            fmt.println(k, v, "(float64)")
        case []interface{}:
            fmt.println(k, "(array):")
            for _, u := range v {
                //fmt.println("    ", i, u)
                u := u.(map[string]interface{})
                for a,b := range u {
                    if a == "metadata" {
                        b := b.(map[string]interface{})
                        for c,e := range b {
                            if c == "name" {
                                fmt.println(e)
                            }
                        }
                    }
                    //fmt.println("    ", a, b)
                }
            }
        default:
            fmt.println(k, v, "(unknown)")
        }
    }
}

输出：

kind PodList (string)
apiVersion v1 (string)
metadata map[] (unknown)
items (array):
super-user-pod5551

最好的方法是为对象定义 struct ，但我有兴趣了解如何在没有 struct 的情况下执行此操作。

问题是您没有像您声称的那样进行类型转换。相反，您正在执行类型断言。

由于 pods["items"] 是一个 []interface{}，因此您首先需要每个接口都有一个具体类型的 []byte 并对每个接口进行断言并将其收集到 [] 中byte，然后才能执行 unmarshal。

最终，您应该创建一个 struct，您可以简单地对其进行解组，这将大大简化您的代码。

正如其他人所说，您解组两次的事实应该表明有更好的方法。

好了，本文到此结束，带大家了解了《无法将interface{}转换为字节：“interface{}是接口，而不是字节”》，希望本文对你有所帮助！关注golang学习网公众号，给大家分享更多Golang知识！