golang JSON的使用

json 是当前最常用的数据传输格式之一，纯文本，容易使用，方便阅读，在通信过程中大量被使用。

利用结构体进行转换

golang对json的解析函数在encoding/json里面，主要是编码和解码两个函数。

json.Marshal

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

Marshal函数将会递归遍历整个对象，依次按成员类型对这个对象进行编码，类型转换规则如下：

Golang 数据类型	JSON 数据类型
bool	Boolean
int float	Number
string	JSON String 带”“
struct	JSON Object 再根据成员递归打包
数组或切片	JSON Array
[]byte	base64编码后的JSON String
map	JSON Object， key必须是string
interface{}	按照内部实际进行转换
nil	null
channel, func	UnsupportedTypeError

package main                                                                             

import(                                                                                  
        "encoding/json"                                                                  
        "fmt"                                                                            
      )                                                                                  

type Per struct{                                                                         
    Name string                                                                          
    Position string                                                                      
}                                                                                        
func main(){                                                                             
    var p Per                                                                            
    str := `{"name":"archmage","position":"beijing"}`                                    
    err := json.Unmarshal([]byte(str),&p)                                                
    if err !=nil{                                                                        
        fmt.Println("err",err)                                                          
    }                                                                                    

    fmt.Println(p)
    fmt.Println(p.Name)
    fmt.Println(p.Position)
}

json.Unmarshal

按照上述规则对json字符串进行解析，结果放到data里面

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

示例代码

package main                                                                             

import(                                                                                  
        "encoding/json"                                                                  
        "fmt"                                                                            
      )                                                                                  

type Per struct{                                                                         
    Name string                                                                          
    Position string                                                                      
}                                                                                        
func main(){                                                                             
    var p Per                                                                            
    str := `{"name":"archmage","position":"beijing"}`                                    
    err := json.Unmarshal([]byte(str),&p)                                                
    if err !=nil{                                                                        
        fmt.Println("err",err)                                                          
    }                                                                                    

    fmt.Println(p)                                                                       
    //重新赋值后，生成新的json字符串                                                                                    
    p.Name = "archmage-json"                                                             

    b,err := json.Marshal(p)                                                             
    if err != nil{                                                                       
        fmt.Println("err 2", err)                                                       
    }                                                                                    
    fmt.Println(string(b))                                                               
}

需要注意的：golang只能将json数据解析到结构体中首字母是大写的变量中个，结构体中首字母是小写的变量，将会被忽略。json格式是大小写字母不敏感的，解析过程中，golang将自动匹配。例如上述解析过程中，结构体中的name应该为Name，而json字符串中不管是name 还是NaMe或者是nAmE,都会被解析到结构体的Name.

利用interface{} 进行转换

package main                                                                                                                                                                      

import(
        "encoding/json"
        "fmt"
      )   
func main(){
    var p map[string]interface{}
    str := `{"name":"archmage","position":"beijing","data":[{"ip":1,"num":11},{"ip":2,"num":22}]}`
    err := json.Unmarshal([]byte(str),&p)
    if err !=nil{
        fmt.Println("err",err)
    }   

    name, ok := p["name"].(string)
    if !ok {
        fmt.Println("can not resolve name", err)
    }   
    position, ok := p["position"].(string)
    if !ok {
        fmt.Println("can not resolve position", err)
    }   
    fmt.Println("name:",name)
    fmt.Println("position:",position)

    data,ok := p["data"].([]interface{})
    if !ok {
        fmt.Println("can not resolve data",err)
        return
    }   

    for i,idata := range data{
        d, ok := idata.(map[string]interface{})
        if !ok {
            fmt.Println(err)
            continue
        }
        fmt.Println("第",i,"组数据")
        fmt.Println("ip:",d["ip"].(float64))
        fmt.Println("num:", d["num"].(float64))
    }
}