2018年时已过半，在今年的区块链热潮中，国内各家科技巨头均已粉墨登场，开始在这个新兴领域里高地。但在具体布局细节上，几大巨头又各有不同，从中亦可窥见它们各自对区块链的重视程度和期许方向。

　　兄弟连Go语言全栈与区块链技术培训课程是由清华、微软和谷歌历时半年时间研发出的无二的体系化课程。课程涵盖9大学习阶段，及多个企业级项目实战和来自世界区块链比赛作品，并由以微软区块链具价值尹成为代表的清华系区块链团队亲临授课，综合提员的职场竞争力。

JavaScript Object Notation(JSON)是一个数据交换标准，因其简单、可读性强广泛使用。Go语言中有一个"encoding/json"标准包，里面有完整的解析JSON字符串的功能支持

Go类型和JSON类型的对应关系如下：

bool 代表 JSON booleans,

浮点数, 整数, Number -> JSON number，

string 代表 JSON strings,

nil 代表 JSON null.

数组、切片 -> JSON数组

struct、map -> JSON object

（1）将JSON数据解析成结构体，需要用到 Unmarshal 函数，该函数的源码如下

func Unmarshal(data []byte, v interface{}) error {

    //检查结构良好。

    //避免填写半数据结构

    //在发现JSON语法错误之前

   var d decodeState

   err := checkValid(data, &d.scan)

   if err != nil {

      return err

   }

   d.init(data)

   return d.unmarshal(v)

}

解析示例

首先定义一个结构体与数组切片

//与json数据对应的结构体

type Server struct {

   ServerName string

   ServerIP   string

}

// 数组对应slice

type ServerSlice struct {

   Servers []Server

}

然后将JSON数据解析成结构体

package main

import (

   "encoding/json"

   "fmt"

)

func main()  {

   var s ServerSlice

   str := `{"servers":[{"serverName":"TianJin","serverIP":"127.0.0.1"},

{"serverName":"Beijing","serverIP":"127.0.0.2"}]}`

   json.Unmarshal([]byte(str), &s)

   fmt.Println(s)

}

----output-----

{[{TianJin 127.0.0.1} {Beijing 127.0.0.2}]}

按照上述代码可以正常的将JSON解析成结构体，JSON在struct字段相中查找对应的字段有以下几个规则：

①首先会查找struct字段中所有的可导出的struct字段(所谓可导出就是字母大写)，然后去自己的JSON数据中找对应字段的数据

②JSON数据中对应的字段无关大小写，只要值相同即可

因此上面的Server 结构体中的 ServerName 改为 serverName的话，输出结果就只有后面的 ServerIP 了

{[{ 127.0.0.1} { 127.0.0.2}]}

（2）将结构体解析为JSON数据，需要用到 Unmarshal 函数，该函数的源码如下

func Marshal(v interface{}) ([]byte, error) {

   e := &encodeState{}

   err := e.marshal(v, encOpts{escapeHTML: true})

   if err != nil {

      return nil, err

   }

   return e.Bytes(), nil

}

将结构体解析成JSON数据

func main()  {

   var s ServerSlice

   s.Servers = append(s.Servers,Server{ServerName:"TianJin",

ServerIP:"127.0.0.1"})

   s.Servers = append(s.Servers,Server{ServerName:"BeiJing",

ServerIP:"127.0.0.1"})

   if data, err := json.Marshal(s); err == nil {

      fmt.Printf("%s\n", data)

   }

}

---output---

{"Servers":[{"ServerName":"TianJin","ServerIP":"127.0.0.1"},

{"ServerName":"BeiJing","ServerIP":"127.0.0.1"}]}

如果我们要自己定义生成的JSON数据的字段名呢？我们可以通过 struct tag定义来实现

//与json数据对应的结构体

type Server struct {

   ServerName string `json:"serverName1"`

   ServerIP string `json:"serverIP2"`

}

// 数组对应slice

type ServerSlice struct {

   Servers []Server `json:"servers3"`

}

上面的JSON就会变为下面结果

{"servers3":[{"serverName1":"TianJin","serverIP2":"127.0.0.1"},

{"serverName1":"BeiJing","serverIP2":"127.0.0.1"}]}

针对JSON的输出，我们在定义struct tag的时候需要注意的几点是:

1 字段的tag是 "-" ，那么这个字段不会输出到JSON

2 tag中带有自定义名称，那么这个自定义名称会出现在JSON的字段名中，例如上面例子中serverName

3 tag中如果带有 "omitempty" 选项，那么如果该字段值为空，就不会输出到JSON串中

4 如果字段类型是bool, string, int, int64等，而tag中带有 ",string" 选项，那么这个字段在输出到JSON的时候会把该字段对应的值转换成JSON字符串

举例说明

type Server struct {

   // ID  不会导出到 JSON 中

   ID int `json:"-"`

   // ServerName 会在JSON中被 serverName 覆盖

   ServerName string `json:"serverName"`

    //转换成JSON字符串

   ServerName2 string `json:"serverName2,string"`

   //  如果 ServerIP  为空，则不输出到 JSON 串中

   ServerIP string `json:"serverIP,omitempty"`

}

s := Server {

   ID: 3,

   ServerName: `Go "1.0" `,

   ServerName2: `Go "1.0" `,

   ServerIP: ``,

}

b, _ := json.Marshal(s)

os.Stdout.Write(b)

会输出以下内容：

{"serverName":"Go \"1.0\" ","serverName2":"\"Go \\\"1.0\\\" \""}

Marshal函数只有在转换成功的时候才会返回数据，在转换的过程中我们需要注意几点：

①JSON对象只支持string作为key，所以要编码一个map，那么必须是map[string]T这种类型(T是Go语言中任意的类型)

②Channel, complex和function是不能被编码成JSON的

③嵌套的数据是不能编码的，不然会让JSON编码进入死循环

④指针在编码的时候会输出指针指向的内容，而空指针会输出null

上面解析方式是在我们知晓被解析的JSON数据的结构的前提下采取的方案，如果我们不知道被解析的数据的格式，又应该如何来解析呢？

（3）将JSON解析到interface

现在我们假设有如下的JSON数据

b := []byte(`{"Name":"Wednesday","Age":6,"Parents":["Gomez","Morticia"]}`)

在我们不知道他的结构的情况下，我们把他解析到interface{}里面

var f interface{}

err := json.Unmarshal(jsonData, &f)

这个时候f里面存储了一个map类似，他们的key是string，值存储在空的interface{}里

f = map[string]interface{}{

    "Name": "Wednesday",

    "Age": 6,

    "Parents": []interface{}{

                "Gomez",

                "Morticia",

    }，

}

那么如何来访问这些数据呢？通过断言的方式：

m := f.(map[string]interface{})

通过断言之后，你就可以通过如下方式来访问里面的数据了

for k, v := range m {

   switch vv := v.(type) {

   case string:

      fmt.Println(k, "is string", vv)

   case int:

      fmt.Println(k, "is int", vv)

   case []interface{}:

      fmt.Println(k, "is an array:")

      for i, u := range vv {

         fmt.Println(i, u)

      }

   default:

      fmt.Println(k, "is of a type I don't know how to handle")

   }

}

高能预警，兄弟连教育区块链直播课程8月持续火爆来袭！

原价1188元的12节区块链进阶课程，现仅需1元！

还可取《Go语言基础实战项目开发》与《Go语言实战项目开发》教材两本！！

限量！！先到先得！！

http://www.ydma.cn/open/course/24

关注兄弟连区块链技术公众号领取更多技术干货哦！！！