🌈Don't worry , just coding!
内耗与overthinking只会削弱你的精力,虚度你的光阴,每天迈出一小步,回头时发现已经走了很远。
📗概念
在 Go 语言中,处理 JSON 数据主要依赖于 encoding/json 包。这个包提供了编码(序列化)和解码(反序列化)JSON 数据的功能。
💻代码
Example
go
package main
//导入了 encoding/json(用于处理 JSON 数据)、fmt(用于格式化输出)和 os(用于操作系统功能)包。
import (
"encoding/json"
"fmt"
"os"
)
// 定义了两个结构体 response1 和 response2。
// response2 使用了结构体标签(tags),指定了 JSON 字段名,这样在序列化时可以控制字段名称
type response1 struct {
Page int//首字母必须大写才能导出字段
Fruits []string
}
type response2 struct {
Page int `json:"page"`
Fruits []string `json:"fruits"`
}
func main() {
//使用 json.Marshal 将其转换为 JSON 格式的字节切片,并转为字符串输出。
bolB, _ := json.Marshal(true)
fmt.Println(string(bolB)) // 输出: true
intB, _ := json.Marshal(1)
fmt.Println(string(intB)) // 输出: 1
fltB, _ := json.Marshal(2.34)
fmt.Println(string(fltB)) // 输出: 2.34
strB, _ := json.Marshal("gopher")
fmt.Println(string(strB)) // 输出: "gopher"
slcD := []string{"apple", "peach", "pear"}
slcB, _ := json.Marshal(slcD)
fmt.Println(string(slcB)) // 输出: ["apple","peach","pear"]
mapD := map[string]int{"apple": 5, "lettuce": 7}
mapB, _ := json.Marshal(mapD)
fmt.Println(string(mapB)) // 输出: {"apple":5,"lettuce":7}
res1D := &response1{
Page: 1,
Fruits: []string{"apple", "peach", "pear"}}
res1B, _ := json.Marshal(res1D)
fmt.Println(string(res1B)) // 输出: {"Page":1,"Fruits":["apple","peach","pear"]}
res2D := &response2{
Page: 1,
Fruits: []string{"apple", "peach", "pear"}}
res2B, _ := json.Marshal(res2D)
fmt.Println(string(res2B)) // 输出: {"page":1,"fruits":["apple","peach","pear"]}
byt := []byte(`{"num":6.13,"strs":["a","b"]}`)
var dat map[string]interface{}
if err := json.Unmarshal(byt, &dat); err != nil {
panic(err)
}
fmt.Println(dat) // 输出: map[num:6.13 strs:[a b]]
num := dat["num"].(float64)//num是float的类型,这里需要手动转化
fmt.Println(num)
strs := dat["strs"].([]interface{})
str1 := strs[0].(string)
fmt.Println(str1)
str := `{"page": 1, "fruits": ["apple", "peach"]}`
res := response2{}
//[]byte(str) 将 JSON 字符串 str 转换为字节切片,以便 Unmarshal 函数可以处理。
//&res 是一个指向 res 的指针,表示解码后的数据将存储在 res 中。
json.Unmarshal([]byte(str), &res)
fmt.Println(res) // 输出: {1 [apple peach]}
fmt.Println(res.Fruits[0]) // 输出: apple
//使用 json.NewEncoder 创建一个 JSON 编码器,将数据直接编码到标准输出流(os.Stdout)。
enc := json.NewEncoder(os.Stdout)
d := map[string]int{"apple": 5, "lettuce": 7}
enc.Encode(d) // 输出: {"apple":5,"lettuce":7}
}
//输出
//true
//1
//2.34
//"gopher"
//["apple","peach","pear"]
//{"apple":5,"lettuce":7}
//{"Page":1,"Fruits":["apple","peach","pear"]}
//{"page":1,"fruits":["apple","peach","pear"]}
//map[num:6.13 strs:[a b]]
//6.13
//a
//{1 [apple peach]}
//apple
//{"apple":5,"lettuce":7}
序列化
将 Go 数据结构转换为 JSON 格式的字符串。
go
package main
import (
"encoding/json"
"fmt"
)
func main() {
// 示例数据
data := map[string]interface{}{
"name": "Alice",
"age": 30,
"hobbies": []string{"reading", "traveling"},
}
// 编码为 JSON
jsonData, err := json.Marshal(data)
if err != nil {
fmt.Println("Error encoding JSON:", err)
return
}
fmt.Println(string(jsonData)) // 输出: {"age":30,"hobbies":["reading","traveling"],"name":"Alice"}
}
反序列化
将 JSON 格式的字符串转换为 Go 数据结构。
go
package main
import (
"encoding/json"
"fmt"
)
func main() {
jsonStr := `{"name": "Alice", "age": 30, "hobbies": ["reading", "traveling"]}`
var data map[string]interface{}
// 解码 JSON
err := json.Unmarshal([]byte(jsonStr), &data)
if err != nil {
fmt.Println("Error decoding JSON:", err)
return
}
fmt.Println(data) // 输出: map[age:30 hobbies:[reading traveling] name:Alice]
}
切片序列化
Go 的切片可以直接映射到 JSON 数组。
go
func main() {
fruits := []string{"apple", "banana", "cherry"}
jsonData, err := json.Marshal(fruits)
if err != nil {
fmt.Println("Error encoding JSON:", err)
return
}
fmt.Println(string(jsonData)) // 输出: ["apple","banana","cherry"]
}
使用 JSON 标签
通过结构体标签自定义 JSON 字段名。
go
type Person struct {
Name string `json:"name"`
Age int `json:"age"`
Hobbies []string `json:"hobbies"`
}
序列化结构体
go
package main
import (
"encoding/json"
"fmt"
)
//定义结构体
type Person struct {
Name string `json:"name"`
Age int `json:"age"`
Hobbies []string `json:"hobbies"`
}
func main() {
person := Person{
Name: "Alice",
Age: 30,
Hobbies: []string{"reading", "traveling"},
}
//序列化结构体
jsonData, err := json.Marshal(person)
if err != nil {
fmt.Println("Error encoding JSON:", err)
return
}
fmt.Println(string(jsonData)) // 输出: {"age":30,"hobbies":["reading","traveling"],"name":"Alice"}
}
反序列化结构体
go
func main() {
jsonStr := `{"name": "Alice", "age": 30, "hobbies": ["reading", "traveling"]}`
var person Person
//[]byte(jsonStr) 将一个字符串(jsonStr)转换为字节切片。这是因为 json.Unmarshal 需要一个字节切片作为输入参数,而不是字符串。
err := json.Unmarshal([]byte(jsonStr), &person)
if err != nil {
fmt.Println("Error decoding JSON:", err)
return
}
fmt.Println(person) // 输出: {Alice 30 [reading traveling]}
}
- 在 Go 中,json.Unmarshal 函数用于将 JSON 格式的字节切片解码为 Go 数据结构。这里的 []byte 是一个字节切片类型,表示 JSON 数据的原始字节序列。
- 字节切片:[]byte 是 Go 中的一个基本数据类型,表示一个字节的动态数组。每个字节是一个 8 位的无符号整数,通常用于表示原始数据,如文本、二进制数据等。
- JSON 字符串:在 JSON 数据的上下文中,JSON 字符串通常是以 UTF-8 编码的文本。要将 JSON 字符串转换为 Go 数据结构,首先需要将其转换为字节切片。
🔍理解
- 序列化是把go的数据结构转为json格式,用json.Marshal(data)
- 反序列化是把json格式转为go的数据格式,用json.Unmarshal
💡 Tips小知识点
错误处理
在编码和解码过程中,建议检查错误,以确保数据的正确性。
go
if err != nil {
fmt.Println("Error:", err)
}
JSON 编码到输出流
使用 json.Encoder 将 JSON 数据直接写入到输出流(如标准输出)。
go
enc := json.NewEncoder(os.Stdout)
data := map[string]int{"apple": 5, "banana": 2}
enc.Encode(data) // 输出: {"apple":5,"banana":2}
💪无人扶我青云志,我自踏雪至山巅。