golang JSON的使用

版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/guokaikevin/article/details/78801365

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))
    }
}

猜你喜欢

转载自blog.csdn.net/guokaikevin/article/details/78801365