Golang json.Marshal 和 json.Unmarshal区别

Golang json.Marshal 和 json.Unmarshal区别是什么 我来详细解释一下 JSON Marshal 和 Unmarshal 在 Go 语言中的含义和用法。

JSON Marshal（序列化）

Marshal 是指将 Go 的数据结构转换为 JSON 字符串的过程。

基本用法：

package main

import (
    "encoding/json"
    "fmt"
)

type Person struct {
    Name string `json:"name"`
    Age  int    `json:"age"`
    City string `json:"city"`
}

func main() {
    // 创建结构体实例
    person := Person{Name: "张三", Age: 25, City: "北京"}
    
    // Marshal：Go结构体 → JSON字符串
    jsonData, err := json.Marshal(person)
    if err != nil {
        fmt.Println("Error:", err)
        return
    }
    
    fmt.Println(string(jsonData))
    // 输出: {"name":"张三","age":25,"city":"北京"}
}

格式化输出：

jsonData, _ := json.MarshalIndent(person, "", "  ")
fmt.Println(string(jsonData))
// 输出：
// {
//   "name": "张三",
//   "age": 25,
//   "city": "北京"
// }

JSON Unmarshal（反序列化）

Unmarshal 是指将 JSON 字符串转换回 Go 数据结构的过程。

基本用法：

func main() {
    // JSON 字符串
    jsonString := `{"name":"李四","age":30,"city":"上海"}`
    
    // 创建目标结构体
    var person Person
    
    // Unmarshal：JSON字符串 → Go结构体
    err := json.Unmarshal([]byte(jsonString), &person)
    if err != nil {
        fmt.Println("Error:", err)
        return
    }
    
    fmt.Printf("Name: %s, Age: %d, City: %s\n", 
        person.Name, person.Age, person.City)
    // 输出: Name: 李四, Age: 30, City: 上海
}

更多示例

1. 处理切片和映射

// Marshal 切片
numbers := []int{1, 2, 3, 4, 5}
jsonData, _ := json.Marshal(numbers)
fmt.Println(string(jsonData)) // [1,2,3,4,5]

// Unmarshal 到切片
var newNumbers []int
json.Unmarshal(jsonData, &newNumbers)
fmt.Println(newNumbers) // [1 2 3 4 5]

2. 处理嵌套结构

type Address struct {
    Street  string `json:"street"`
    ZipCode string `json:"zip_code"`
}

type User struct {
    Name    string  `json:"name"`
    Address Address `json:"address"`
}

func main() {
    user := User{
        Name: "王五",
        Address: Address{
            Street:  "人民路123号",
            ZipCode: "100000",
        },
    }
    
    jsonData, _ := json.Marshal(user)
    fmt.Println(string(jsonData))
    // {"name":"王五","address":{"street":"人民路123号","zip_code":"100000"}}
}

3. 处理未知结构的 JSON

func main() {
    jsonString := `{"name":"赵六","age":28,"hobbies":["读书","游泳"]}`
    
    // 使用 map[string]interface{} 接收未知结构
    var data map[string]interface{}
    json.Unmarshal([]byte(jsonString), &data)
    
    fmt.Println(data["name"]) // 赵六
    fmt.Println(data["age"])  // 28
    
    // 类型断言
    if hobbies, ok := data["hobbies"].([]interface{}); ok {
        for _, hobby := range hobbies {
            fmt.Println(hobby)
        }
    }
}

重要注意事项

1. 字段必须导出（首字母大写）才能被 Marshal
2. JSON tag 可以自定义字段名
3. Unmarshal 需要传递指针
4. 错误处理很重要

type Product struct {
    ID    int     `json:"id"`
    Name  string  `json:"name"`
    Price float64 `json:"price"`
    // 小写字段不会被序列化
    secret string
}

总结

• Marshal: Go → JSON（序列化）
• Unmarshal: JSON → Go（反序列化）
• 使用 encoding/json 包
• 结构体字段需要添加 JSON tag
• 记得处理错误

这两个操作在 Web 开发、API 通信、配置文件处理等场景中非常常用。