目录
  • 概述
  • json序列化
    • 结构体转json
    • map转json
    • 切片转json
  • json反序列化
    • json转map
    • json转结构体
    • json转切片
  • 写json文件
    • map写入json文件
    • 切片写入json文件
    • 结构体写入json文件
  • 读json文件
    • 解码json文件为map
    • 解码json文件为切片
    • 解码json文件为结构体
  • 示例

    概述

    json(javascript object notation,javascript对象表示法)是一种轻量级的、键值对的数据交换格式。结构由大括号'{}’,中括号'[]’,逗号’,’,冒号’;’,双引号'””‘组成,包含的数据类型有object,number,boolean,string,array, null等。

    json序列化

    将go语言原数据转换成json格式字符串

    语法:

    //传map,结构体,slice...,返回结果byte切片和error是否错误
    func marshal(v interface{}) ([]byte, error)
    

    结构体转json

    type person struct{
       name string   //姓名
       age int       //年龄
       sex rune      //性别
       hobby []string  //爱好
       money float64   //钱
    }  
    person:=person{name:"张三",age:18,sex:'男',hobby:[]string{"听音乐","看书","打篮球"},money:18.62}
    if bytes,err:=json.marshal(person);err!=nil{
      fmt.println("编码错误",err)
    }else{
    //{"name":"张三","age":18,"sex":30007,"hobby":["听音乐","看书","打篮球"],"money":18.62}
      fmt.println("编码成功:",string(bytes))
    }
    

    map转json

    p:=make(map[string]interface{},0)
    p["0"]=map[string]interface{}{"name":"张三","age":18,"sex":'男',"hobby":[]string{"听音乐","看书","打篮球"},"money":18.62}
    p["1"]=map[string]interface{}{"name":"李四","age":19,"sex":'女',"hobby":[]string{"听音乐","看电影","打足球"},"money":1.62}
    
    if bytes,err:=json.marshal(p);err!=nil{
       fmt.println("编码错误",err)
    }else{
       fmt.println(string(bytes))
    }
    

    切片转json

      p:=make([]map[string]interface{},0)
      p1:=map[string]interface{}{"name":"张三","age":18,"sex":'男',"hobby":[]string{"听音乐","看书","打篮球"},"money":18.62}
      p2:=map[string]interface{}{"name":"李四","age":19,"sex":'女',"hobby":[]string{"听音乐","看电影","打足球"},"money":1.62}
      p=append(p,p1,p2)
    
      if bytes,err:=json.marshal(p);err!=nil{
        fmt.println("编码错误",err)
      }else{
        fmt.println(string(bytes))
      }
    

    json反序列化

    将json格式字符串转换成go语言原数据

    //传入json字符串的byte字节和go接收数据的类型指针,返回err错误,是否返回成功
    func unmarshal(data []byte, v interface{}) error
    

    json转map

    str:=`{"name":"张三","age":18,"sex":30007,"hobby":["听音乐","看书","打篮球"],"money":18.62}`
    p:=make(map[string]interface{}, 0)
    if err:=json.unmarshal([]byte(str),&p);err!=nil{
      fmt.println("解码失败",err)
    }else{
      fmt.println("解析成功",p)
    }
    

    json转结构体

    str:=`{"name":"张三","age":18,"sex":30007,"hobby":["听音乐","看书","打篮球"],"money":18.62}`
    var p person
    if err:=json.unmarshal([]byte(str),&p);err!=nil{
      fmt.println("解码失败",err)
    }else{
      fmt.println("解析成功",p)
    }
    

    json转切片

    str:=`[{"hobby":["听音乐","看书","打篮球"]}]`
    p:=make([]map[string]interface{}, 0)
    
    if err:=json.unmarshal([]byte(str),&p);err!=nil{
      fmt.println("解码失败",err)
    }else{
      fmt.println("解析成功",p)
    }
    

    写json文件

    将go语言源数据写入到json文件

    //第一步  传文件的路径,返回文件的可读可写,error:是否成功
    //flag:文件标识:是创建还是,追加......
    //parm:文件模式表示文件的模式和权限位,通常,请求的模式为 0666,它使该文件可由任何人读和写
    func openfile(name string, flag int, perm filemode) (*file, error)
    或者
    func create(name string) (*file, error)  //传入文件的名字,返回文件的对象和error是否成功
    //第二步 传文件对象,返回一个从w读取的新编码器
    func newencoder(w io.writer) *encoder
    //第三步 编码器将v写入流中,后换行
    func (enc *encoder) encode(v interface{}) error
    

    map写入json文件

    p:=make(map[string]interface{}, 0)
    p["name"]="张三"
    p["age"]=18
    p["sex"]='男'
    p["hobby"]=[]string{"听英语","看书"}
    p["money"]=15.63
    if distfile,err:=os.openfile("map.json",os.o_create,0666);err!=nil{
      fmt.println("创建文件失败",err)
    }else {
      enc:=json.newencoder(distfile)
      if err:=enc.encode(p);err!=nil {
        fmt.println("写入文件失败", err)
      }else{
        fmt.println("写入文件成功")
      }
    }
    

    切片写入json文件

    p:=make([]map[string]interface{}, 0)
    p1:=map[string]interface{}{"name":"张三","age":18,"sex":'男',"hobby":[]string{"听书","看电视"},"money":15.84}
    p2:=map[string]interface{}{"name":"李四","age":20,"sex":'女',"hobby":[]string{"打篮球","看书"},"money":125.84}
    p=append(p,p1,p2)
    if distfile,err:=os.openfile("slice.json",os.o_create,0666);err!=nil{
      fmt.println("创建slice文件失败", err)
    }else {
      enc:=json.newencoder(distfile)
      if err:=enc.encode(p);err!=nil{
        fmt.println("写入slice 文件失败", err)
      }else{
        fmt.println("写入slice 文件成功")
      }
    }
    

    结构体写入json文件

    p:=person{name:"张三",age:18,sex:'男',hobby:[]string{"听英语","读书"},money:15.35}
    if distfile,err:=os.openfile("张三.json",os.o_create|os.o_append,0666);err!=nil{
      fmt.println("创建文件失败",err)
    }else{
      enc:=json.newencoder(distfile)
      if err:=enc.encode(&p);err!=nil {
        fmt.println("写入文件失败",err)
      }else {
        fmt.println("写入文件成功")
      }
    }
    

    读json文件

    将json文件转换成go语言源数据

    //第一步  传文件的路径,返回文件的可读可写,error:是否成功
    func open(name string) (*file, error)
    //第二步 传文件对象,返回一个从r读取的新解码器
    func newdecoder(r io.reader) *decoder
    //第三步 解码器将值存储在v值中
    func (dec *decoder) decode(v interface{}) error
    

    解码json文件为map

    p:=make(map[string]interface{}, 0)
    if srcfile,err:=os.open("map.json");err!=nil{
      fmt.println("打开map 文件失败",err)
    }else{
      en:=json.newdecoder(srcfile)
      if err:=en.decode(&p);err!=nil{
        fmt.println("读入map 文件失败",err)
      }else {
        fmt.println("读取map 文件成功",p)
      }
    }
    

    解码json文件为切片

    p:=make([]map[string]interface{}, 0)
    if srcfile,err:=os.open("slice.json");err!=nil{
      fmt.println("打开slice 文件失败", err)
    }else{
      en:=json.newdecoder(srcfile)
      if err:=en.decode(&p);err!=nil{
        fmt.println("读入slice 文件失败", err)
      }else {
        fmt.println("读取slice 文件成功", p)
      }
    }
    
    

    解码json文件为结构体

    var p =new(person)
    if srcfile,err:=os.open("struct.json");err!=nil{
      fmt.println("打开struct 文件失败", err)
    }else{
      en:=json.newdecoder(srcfile)
      if err:=en.decode(&p);err!=nil{
        fmt.println("读入struct 文件失败", err)
      }else{
        fmt.println("读取struct 文件成功", *p)
      }
    }
    

    示例

    package main
    import (
    	"encoding/json"
    	"fmt"
    	"os"
    )
    type person struct {
    	name  string   //姓名
    	age   int      //年龄
    	sex   rune     //性别
    	hobby []string //爱好
    	money float64  //钱
    }
    func main() {
    	fmt.println("---------------json序列化----------")
    	//json序列化
    	//结构体
    	marshalstrut()
    	//map
    	marshalmap()
    	//slice
    	marshalslice()
    	fmt.println("\n", "---------------json反序列化----------", "\n")
    	//json反序列化
    	//map
    	unmarshalmap()
    	//struct
    	unmarshalstruct()
    	//slice
    	unmarshalslice()
    	fmt.println("\n", "---------------写json文件----------", "\n")
    	//结构体
    	writestructfile()
    	//map
    	writemapfile()
    	//slice
    	writeslicefile()
    	fmt.println("\n", "---------------读json文件----------", "\n")
    	//struct
    	readstructfile()
    	//map
    	readmapfile()
    	//slice
    	readslicefile()
    }
    /************************序列化*********************/
    func marshalstrut() {
    	person := person{name: "张三", age: 18, sex: '男', hobby: []string{"听音乐", "看书", "打篮球"}, money: 18.62}
    	if bytes, err := json.marshal(person); err != nil {
    		fmt.println("结构体序列化错误", err)
    	} else {
    		//{"name":"张三","age":18,"sex":30007,"hobby":["听音乐","看书","打篮球"],"money":18.62}
    		fmt.println("结构体序列化成功:", string(bytes))
    	}
    }
    func marshalmap() {
    	p := make(map[string]interface{}, 0)
    	p["0"] = map[string]interface{}{"name": "张三", "age": 18, "sex": '男', "hobby": []string{"听音乐", "看书", "打篮球"}, "money": 18.62}
    	p["1"] = map[string]interface{}{"name": "李四", "age": 19, "sex": '女', "hobby": []string{"听音乐", "看电影", "打足球"}, "money": 1.62}
    
    	if bytes, err := json.marshal(p); err != nil {
    		fmt.println("map 序列化错误", err)
    	} else {
    		// {"0":{"age":18,"hobby":["听音乐","看书","打篮球"],"money":18.62,"name":"张三","sex":30007},"1":{"age":19,"hobby":["听音乐","看电影","打足球"],"money":1.62,"name":"李四","sex":22899}}
    		fmt.println("map 序列化成功", string(bytes))
    	}
    }
    func marshalslice() {
    	p := make([]map[string]interface{}, 0)
    	p1 := map[string]interface{}{"name": "张三", "age": 18, "sex": '男', "hobby": []string{"听音乐", "看书", "打篮球"}, "money": 18.62}
    	p2 := map[string]interface{}{"name": "李四", "age": 19, "sex": '女', "hobby": []string{"听音乐", "看电影", "打足球"}, "money": 1.62}
    	p = append(p, p1, p2)
    	if bytes, err := json.marshal(p); err != nil {
    		fmt.println("slice 序列化错误", err)
    	} else {
    		// [{"age":18,"hobby":["听音乐","看书","打篮球"],"money":18.62,"name":"张三","sex":30007},{"age":19,"hobby":["听音乐","看电影","打足球"],"money":1.62,"name":"李四","sex":22899}]
    		fmt.println("slice 序列化成功", string(bytes))
    	}
    }
    /************************反序列化*********************/
    func unmarshalmap() {
    	str := `{"name":"张三","age":18,"sex":30007,"hobby":["听音乐","看书","打篮球"],"money":18.62}`
    	p := make(map[string]interface{}, 0)
    	if err := json.unmarshal([]byte(str), &p); err != nil {
    		fmt.println("map 反序列化失败", err)
    	} else {
    		//map[age:18 hobby:[听音乐 看书 打篮球] money:18.62 name:张三 sex:30007]
    		fmt.println("map 反序列化成功", p)
    	}
    }
    func unmarshalstruct() {
    	str := `{"name":"张三","age":18,"sex":30007,"hobby":["听音乐","看书","打篮球"],"money":18.62}`
    	var p person
    	if err := json.unmarshal([]byte(str), &p); err != nil {
    		fmt.println("struct 反序列化失败", err)
    	} else {
    		//{张三 18 30007 [听音乐 看书 打篮球] 18.62}
    		fmt.println("struct 反序列化成功", p)
    	}
    }
    func unmarshalslice() {
    	str := `[{"hobby":["听音乐","看书","打篮球"]},{"hobby":["听书","看书","打足球"]}]`
    	p := make([]map[string]interface{}, 0)
    
    	if err := json.unmarshal([]byte(str), &p); err != nil {
    		fmt.println("slice 反序列化失败", err)
    	} else {
    		// [map[hobby:[听音乐 看书 打篮球]]]
    		fmt.println("slice 反序列化成功", p)
    	}
    }
    /************************写json文件*********************/
    func writestructfile() {
    	p := person{name: "张三", age: 18, sex: '男', hobby: []string{"听英语", "读书"}, money: 15.35}
    	if distfile, err := os.openfile("struct.json", os.o_create|os.o_trunc, 0666); err != nil {
    		fmt.println("创建struct文件失败", err)
    	} else {
    		enc := json.newencoder(distfile)
    		if err := enc.encode(&p); err != nil {
    			fmt.println("写入struct文件失败", err)
    		} else {
    			fmt.println("写入struct文件成功")
    		}
    	}
    }
    func writemapfile() {
    	p := make(map[string]interface{}, 0)
    	p["name"] = "张三"
    	p["age"] = 18
    	p["sex"] = '男'
    	p["hobby"] = []string{"听英语", "看书"}
    	p["money"] = 15.63
    	if distfile, err := os.openfile("map.json", os.o_create, 0666); err != nil {
    		fmt.println("创建map 文件失败", err)
    	} else {
    		enc := json.newencoder(distfile)
    		if err := enc.encode(p); err != nil {
    			fmt.println("写入map文件失败", err)
    		} else {
    			fmt.println("写入map 文件成功")
    		}
    	}
    }
    func writeslicefile() {
    	p := make([]map[string]interface{}, 0)
    	p1 := map[string]interface{}{"name": "张三", "age": 18, "sex": '男', "hobby": []string{"听书", "看电视"}, "money": 15.84}
    	p2 := map[string]interface{}{"name": "李四", "age": 20, "sex": '女', "hobby": []string{"打篮球", "看书"}, "money": 125.84}
    	p = append(p, p1, p2)
    	if distfile, err := os.openfile("slice.json", os.o_create, 0666); err != nil {
    		fmt.println("创建slice文件失败", err)
    	} else {
    		enc := json.newencoder(distfile)
    		if err := enc.encode(p); err != nil {
    			fmt.println("写入slice 文件失败", err)
    		} else {
    			fmt.println("写入slice 文件成功")
    		}
    	}
    }
    /************************读json文件*********************/
    func readstructfile() {
    	var p = new(person)
    
    	if err := readfile("struct.json", "打开struct 文件失败", &p); err != nil {
    		fmt.println("读入struct 文件失败", err)
    	} else {
    		fmt.println("读取struct 文件成功", *p)
    	}
    
    }
    func readmapfile() {
    	p := make(map[string]interface{}, 0)
    
    	if err := readfile("map.json", "打开map 文件失败", &p); err != nil {
    		fmt.println("读取map 文件失败", err)
    	} else {
    		fmt.println("读取map 文件成功", p)
    	}
    }
    func readslicefile() {
    	p := make([]map[string]interface{}, 0)
    	if err := readfile("slice.json", "打开slice 文件失败", &p); err != nil {
    		fmt.println("读入slice 文件失败", err)
    	} else {
    		fmt.println("读取slice 文件成功", p)
    	}
    }
    //封装
    func readfile(f string, c string, v interface{}) error {
    	if srcfile := openfile(f, c); srcfile != nil {
    		en := json.newdecoder(srcfile)
    		if err := en.decode(v); err != nil {
    			return err
    		}
    	}
    	return nil
    }
    func openfile(f string, c string) *os.file {
    	if srcfile, err := os.open(f); err != nil {
    		fmt.println(c, err)
    	} else {
    		return srcfile
    	}
    	return nil
    }
    
    

    以上就是go语言基础json序列化反序列化及文件读写示例详解的详细内容,更多关于go语言json序列化反序列化及文件读写的资料请关注www.887551.com其它相关文章!