json库

目录

json库

json结构体从b复制到a

json.Marshal(query)  # 转换为json字符串
json.Unmarshal(strquery)  # json字符串转换为标准json

//a,b结构体不一样，从b复制到a
a:=A{}
bStr, _ := json.Marshal(b)
_ = json.Unmarshal(bStr, &a)

strings.Join字符串拼接

var NetworkSql string
for i := range in.Network {
  NetworkSql = strings.Join([]string{NetworkSql, strconv.Itoa(in.Network[i])}, ",")
}
NetworkSql = string(NetworkSql)[1:]

json字符串转换

import "encoding/json"
json.Marshal(query)  # 转换为json字符串
json.Unmarshal(strquery)  # json字符串转换为标准json


type Student struct {
	Name    string
	Age     int
	Classes []string
	Price   float32
}



func main() {

	st := &Student {
		"jeff",
		18,
		[]string{"math", "English", "Chinese"},
		9.99,
	}
	b, _ := json.Marshal(st)
	fmt.Println(string(b))  //{"Name":"jeff","Age":18,"Classes":["math","English","Chinese"],"Price":9.99}

	stb := &Student{}
	_ = json.Unmarshal([]byte(b), &stb)
	fmt.Println(stb) //&{jeff 18 [math English Chinese] 9.99}
}

redis map转结构体

package main

import (
	"encoding/json"
	"fmt"
	"github.com/go-redis/redis"
)

var rdb *redis.Client

func initClient() (err error) {
	rdb = redis.NewClient(&redis.Options{
		Addr:     "127.0.0.1",
		Password: "", // no password set
		DB:       4,  // use default DB
	})

	_, err = rdb.Ping().Result()
	if err != nil {
		return err
	}
	return nil
}

type bike struct {
	Acc string `json:"acc"`
	CcID string `json:"cc_id"`
}

func main() {
	err := initClient()
	if err != nil {
		fmt.Println(err)
	}
	value, err2 := rdb.HGetAll("br:10066").Result()
	if err2 != nil {
		fmt.Println(err2)
	}
	//fmt.Printf("%T",value) //map[string]string
	//fmt.Println(value)
	//// 遍历每一个字段
	//a:=value["cc_id"]
	//fmt.Println(a) // 10066
	//// 每一个字段一个个初始化，怎么样可以直接传入&bike,自动初始化
	//b := bike{
	//	Cc_id: a,
	//}
	//fmt.Printf("%+v",b) // {cc_id:10066}

	//var src []map[string]string

	json_ret, err := json.Marshal(value)
	if err != nil {
		fmt.Println(err)
	}
	var bike_test bike
	err = json.Unmarshal(json_ret, &bike_test)
	if err != nil {
		fmt.Println(err)
	}
	fmt.Printf("%+v", bike_test)
}

json结构体转interface

b, _ := json.Marshal(&traveList)
var m []interface{}
_ = json.Unmarshal(b, &m)


//2. omitempty忽略零值和nil值
type User struct {
		Name string `json:"name,omitempty"`
		Age  int    `json:"age,omitempty"`
	}
	jeff := User{
		Name: "Jeff",
	}
	fmt.Println(jeff)

	b, _ := json.Marshal(&jeff)
	var m map[string]interface{}
	_ = json.Unmarshal(b, &m)
	fmt.Println(m) //map[name:Jeff]

json字符串转结构体

例子1：

type Info struct {
	Id      int    `json:"id"`
	Code    string `json:"code"`
	HwCode  string `json:"hw_code"`
	Name    string `json:"name"`
	BrandId int    `json:"brand_id"`
}

func jsonTest1()  {
	jsonStr := `{"id":2,"code":"W01","hw_code":"AA5","name":"秋月白","brand_id":1}`
	r:=Info{}
	str:=[]byte(jsonStr)
	json.Unmarshal([]byte(str),&r)
	fmt.Println(r) //{2 W01 AA5 秋月白 1}
}

例子2：[{},{},{}]

type Info struct {
	Id      int    `json:"id"`
	Code    string `json:"code"`
	HwCode  string `json:"hw_code"`
	Name    string `json:"name"`
	BrandId int    `json:"brand_id"`
}

func jsonTest2()  {
	jsonStr := `[{"id":2,"code":"W01","hw_code":"AA5","name":"秋月白","brand_id":1},{"id":3,"code":"W02","hw_code":"AA6","name":"秋月黑","brand_id":2}]`
	r:=Info{}
	list := make([]Info,0)
	var li []map[string]interface{}
	json.Unmarshal([]byte(jsonStr),&li)
	for _,v:=range li{
		arr,_:=json.Marshal(v)
		json.Unmarshal(arr,&r)
		list = append(list, r)
	}
	fmt.Println(list) // [{2 W01 AA5 秋月白 1} {3 W02 AA6 秋月黑 2}]
}

例子3：map[],redis hash

type bike struct {
	Acc string `json:"acc"`
	CcID string `json:"cc_id"`
}

func jsonTest3()  {
	err := initClient()
	if err != nil {
		fmt.Println(err)
	}
	value, err2 := rdb.HGetAll("br:10066").Result()

	if err2 != nil {
		fmt.Println(err2)
	}
	fmt.Println(value)
	json_ret, err := json.Marshal(value)
	if err != nil {
		fmt.Println(err)
	}
	var bike_test bike
	err = json.Unmarshal(json_ret, &bike_test)
	if err != nil {
		fmt.Println(err)
	}
	fmt.Printf("%+v", bike_test)
}

通过结构体生成json

buf, err := json.MarshalIndent(s, "", " ") //格式化编码

package main

import (
	"encoding/json"
	"fmt"
)

//成员变量名首字母必须大写
type IT struct {
	Company  string   `json:"-"`        //此字段不会输出到屏幕
	Subjects []string `json:"subjects"` //二次编码
	IsOk     bool     `json:",string"`
	Price    float64  `json:",string"`
}

func main() {
	//定义一个结构体变量，同时初始化
	s := IT{"itcast", []string{"Go", "C++", "Python", "Test"}, true, 666.666}

	//编码，根据内容生成json文本
	//{"Company":"itcast","Subjects":["Go","C++","Python","Test"],"IsOk":true,"Price":666.666}
	//buf, err := json.Marshal(s)
	buf, err := json.MarshalIndent(s, "", "	") //格式化编码
	if err != nil {
		fmt.Println("err = ", err)
		return
	}
	fmt.Println(string(buf))
}

通过map生成json

package main

import (
	"encoding/json"
	"fmt"
)

func main() {
	//创建一个map
	m := make(map[string]interface{}, 4)
	m["company"] = "itcast"
	m["subjects"] = []string{"Go", "C++", "Python", "Test"}
	m["isok"] = true
	m["price"] = 666.666

	//编码成json
	//result, err := json.Marshal(m)
	result, err := json.MarshalIndent(m, "", "	")
	if err != nil {
		fmt.Println("err = ", err)
		return
	}
	fmt.Println("result = ", string(result))
}

json解析到结构体

err := json.Unmarshal([]byte(jsonBuf), &tmp) //第二个参数要地址传递

package main

import (
	"encoding/json"
	"fmt"
)

type IT struct {
	Company  string   `json:"company"`
	Subjects []string `json:"subjects"` //二次编码
	IsOk     bool     `json:"isok"`
	Price    float64  `json:"price"`
}

func main() {

	jsonBuf := `
	{
    "company": "itcast",
    "subjects": [
        "Go",
        "C++",
        "Python",
        "Test"
    ],
    "isok": true,
    "price": 666.666
}`

	var tmp IT                                   //定义一个结构体变量
	err := json.Unmarshal([]byte(jsonBuf), &tmp) //第二个参数要地址传递
	if err != nil {
		fmt.Println("err = ", err)
		return
	}
	//fmt.Println("tmp = ", tmp)
	fmt.Printf("tmp = %+v\n", tmp)

	type IT2 struct {
		Subjects []string `json:"subjects"` //二次编码
	}

	var tmp2 IT2
	err = json.Unmarshal([]byte(jsonBuf), &tmp2) //第二个参数要地址传递
	if err != nil {
		fmt.Println("err = ", err)
		return
	}
	fmt.Printf("tmp2 = %+v\n", tmp2)

}

json解析到map

package main

import (
	"encoding/json"
	"fmt"
)

func main() {
	jsonBuf := `
	{
    "company": "itcast",
    "subjects": [
        "Go",
        "C++",
        "Python",
        "Test"
    ],
    "isok": true,
    "price": 666.666
}`

	//创建一个map
	m := make(map[string]interface{}, 4)

	err := json.Unmarshal([]byte(jsonBuf), &m) //第二个参数要地址传递
	if err != nil {
		fmt.Println("err = ", err)
		return
	}
	fmt.Printf("m = %+v\n", m)

	//	var str string
	//	str = string(m["company"]) //err， 无法转换
	//	fmt.Println("str = ", str)

	var str string

	//类型断言, 值，它是value类型
	for key, value := range m {
		//fmt.Printf("%v ============> %v\n", key, value)
		switch data := value.(type) {
		case string:
			str = data
			fmt.Printf("map[%s]的值类型为string, value = %s\n", key, str)
		case bool:
			fmt.Printf("map[%s]的值类型为bool, value = %v\n", key, data)
		case float64:
			fmt.Printf("map[%s]的值类型为float64, value = %f\n", key, data)
		case []string:
			fmt.Printf("map[%s]的值类型为[]string, value = %v\n", key, data)
		case []interface{}:
			fmt.Printf("map[%s]的值类型为[]interface, value = %v\n", key, data)
		}

	}

}
posted @ 2023-10-06 21:06  Jeff的技术栈  阅读(46)  评论(1)  编辑  收藏  举报
回顶部