Golang之JSON处理

对post获取的JSON类型的字符串转换为结构体类型

1
2
3
4
5
6
7
8
9
func SetMsg(takerOrderParam ,makerOrderParams ,perpetual,amount string)(ReceiveMessage,OrderParams){
	msg := ReceiveMessage{}
	_ = json.Unmarshal([]byte(takerOrderParam), &msg.TakerOrderParam)
	_ = json.Unmarshal([]byte(makerOrderParams), &msg.MakerOrderParams)
	_ = json.Unmarshal([]byte(amount), &msg.Amounts)
	msg.Perpetual = common.HexToAddress(perpetual)
	orderParams := SetOrders(msg)
	return msg ,orderParams
}

对tcp获取的JSON类型的字符串转换为结构体类型

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
listener, err := net.Listen("tcp", "0.0.0.0:2526")
if err != nil {
	fmt.Println("监听err = ", err)
	return
}
defer listener.Close()
//阻塞，等待用户链接

conn, err := listener.Accept()
if err != nil {
	fmt.Println("链接err = ", err)
	return
}
//接收用户请求
msg := ReceiveMessage{}
_ = json.NewDecoder(conn).Decode(&msg)

json解析到map

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
package main

import (
	"encoding/json"
	"fmt"
)

func main()  {
	jsonBuf := `
	{
    "IsOk":true,
    "company":"itcast",
    "price":66.66,
    "subject":[
        "GO",
        "C++",
        "PHP"
    ]
}`
	m:=make(map[string]interface{},4)

	err:=json.Unmarshal([]byte(jsonBuf),&m)
	if err!=nil{
		return
	}
	fmt.Printf("IT , %+v\n" , m)

}

JSON解析到结构体

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
package main

import (
	"encoding/json"
	"fmt"
)

type IT1 struct {
	Company string   `json:"company"` 
	Subject []string `json:"subjects"`       
	IsOk    bool     `json:"ison"`
	price   float64	 `json:"price"`
}


func main() {
	jsonBuf := `
	{
    "IsOk":true,
    "company":"itcast",
    "price":66.66,
    "subject":[
        "GO",
        "C++",
        "PHP"
    ]
}`
	var tmp IT1  //定义一个结构体变量
	err:=json.Unmarshal([]byte(jsonBuf),&tmp)
	if err!=nil{
		return
	}
	fmt.Printf("IT , %+v\n" , tmp)
}

通过map生成json

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
package main

import (
	"encoding/json"
	"fmt"
)

func main() {
	//创建一个map
	m := make(map[string]interface{}, 4)
	m["company"] = "itcast"
	m["subject"] = []string{"GO", "C++", "PHP"}
	m["IsOk"] = true
	m["price"] = 66.66

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

通过结构体生成JSON

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
package main

import (
	"encoding/json"
	"fmt"
)

//json表现为键/值对集合的文本描述形式，使它成为较为理想的、跨平台、跨语言的数据交换语言

type IT struct {
	Company string   `json:"company"` //变小写
	Subject []string `json:"-"`       //此字段不会输出
	IsOk    bool     `json:",string"` //转换字符串类型再输出
	price   float64
}

func main() {
	//定义一个结构体变量同时初始化
	s := IT{
		Company: "Itcast",
		Subject: []string{"GO", "C++", "PHP"},
		IsOk:    true,
		price:   66.66,
	}

	//编码，根据内容生成json文本
	//buf,err:=json.Marshal(s) //不格式化
	buf, err := json.MarshalIndent(s, "", "   ") //格式化
	if err != nil {
		return
	}
	fmt.Println("buf = ", string(buf))
}