GO语言基础教程（181）Go解析JSON之解码JSON：Go语言解码JSON全攻略｜从菜鸟到大佬，看完这篇再也不怕乱码了！

嘿朋友们！今天咱们来聊聊Go语言里那个让人又爱又恨的活儿——解析JSON。都说Go是服务器开发的扛把子，但当你第一次面对一堆乱麻似的JSON数据时，是不是也曾经懵逼过？别慌，今天这篇干货就是要带你从“JSON恐惧症”患者升级为“解码大师”！

一、为什么JSON在Go里这么重要？

先扯点实在的，现在哪个API不回传JSON数据？从微信支付到抖音接口，从爬虫数据到配置文件，JSON简直就是程序员世界的通用货币。而Go自带的encoding/json包，就是我们的点钞机啊！

不过这个点钞机有点脾气：你要是没搞懂规则，分分钟给你吐出一堆乱码或者直接panic。别问我怎么知道的，说多了都是泪😭

二、基础操作：先把简单的JSON搞定

来看个最简单的例子，假设我们要处理用户数据：

package main

import (
    "encoding/json"
    "fmt"
)

type User struct {
    ID       int    `json:"id"`
    Username string `json:"name"`
    Email    string `json:"email"`
}

func main() {
    // 这是我们从API拿到的一坨JSON
    jsonData := `{"id": 123, "name": "码农小明", "email": "xiaoming@dev.com"}`
    
    var user User
    err := json.Unmarshal([]byte(jsonData), &user)
    if err != nil {
        fmt.Println("解析出错啦:", err)
        return
    }
    
    fmt.Printf("用户ID: %d\n", user.ID)
    fmt.Printf("用户名: %s\n", user.Username) 
    fmt.Printf("邮箱: %s\n", user.Email)
}

运行结果：

用户ID: 123
用户名: 码农小明
邮箱: xiaoming@dev.com

敲黑板划重点：

json.Unmarshal() 是咱们的解析神器
第二个参数必须传指针 &user，不然数据就石沉大海了
结构体标签 ` `json:"name"` ` 是关键映射器

三、结构体标签：JSON和Go的“翻译官”

这里有个天坑！Go语言是驼峰命名，JSON常用下划线，这时候就得靠结构体标签来当翻译：

type Product struct {
    ProductID    int     `json:"product_id"`           // JSON用product_id，Go用ProductID
    ProductName  string  `json:"product_name"`         
    Price        float64 `json:"sale_price,omitempty"` // omitempty表示为空就不输出
    InStock      bool    `json:"-"`                    // 减号表示完全忽略这个字段
}

看到没？这个小小的标签能玩出这么多花样！特别是omitempty，做API的时候超级好用。

四、进阶玩法：处理嵌套JSON

现实中的JSON哪有这么简单？来看看这种套娃式的数据怎么处理：

package main

import (
    "encoding/json"
    "fmt"
)

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

type UserDetail struct {
    ID      int     `json:"id"`
    Profile struct {
        RealName string   `json:"real_name"`
        Age      int      `json:"age"`
        Hobbies  []string `json:"hobbies"`
    } `json:"profile"`
    Addresses []Address `json:"addresses"` // 地址数组
}

func main() {
    jsonData := `{
        "id": 666,
        "profile": {
            "real_name": "技术宅小红",
            "age": 25,
            "hobbies": ["coding", "reading", "gaming"]
        },
        "addresses": [
            {
                "city": "北京",
                "street": "海淀区中关村",
                "zip_code": "100080"
            }
        ]
    }`

    var userDetail UserDetail
    if err := json.Unmarshal([]byte(jsonData), &userDetail); err != nil {
        panic(err)
    }

    fmt.Printf("用户ID: %d\n", userDetail.ID)
    fmt.Printf("真实姓名: %s\n", userDetail.Profile.RealName)
    fmt.Printf("爱好: %v\n", userDetail.Profile.Hobbies)
    fmt.Printf("第一个城市: %s\n", userDetail.Addresses[0].City)
}

这个例子包含了结构体嵌套、数组处理，基本上覆盖了日常80%的使用场景。

五、动态JSON：当字段不确定时怎么办？

有时候JSON像女朋友的心情——猜不透啊！这时候就需要interface{}出马了：


func parseDynamicJSON() {
    jsonData := `{
        "type": "video",
        "data": {
            "url": "https://example.com/video.mp4",
            "duration": 120,
            "format": "mp4"
        }
    }`
    
    var result map[string]interface{}
    json.Unmarshal([]byte(jsonData), &result)
    
    data := result["data"].(map[string]interface{})
    fmt.Printf("视频时长: %.0f秒\n", data["duration"].(float64))
}

但是！用interface{}要小心类型断言，不然很容易panic。建议加上类型检查：

if duration, ok := data["duration"].(float64); ok {
    fmt.Printf("视频时长: %.0f秒\n", duration)
} else {
    fmt.Println("duration字段类型不对")
}

六、错误处理：别让bug悄悄溜走

JSON解析最常见的错误有哪些？我给你列了个清单：

字段类型不匹配：JSON字符串往int字段塞
缺少必需字段：结构体里有，JSON里没有
格式错误：多了个逗号少了个引号

改进后的错误处理应该是这样的：

func safeParse(jsonStr string) {
    var user User
    if err := json.Unmarshal([]byte(jsonStr), &user); err != nil {
        switch e := err.(type) {
        case *json.SyntaxError:
            fmt.Printf("JSON语法错误，位置 %d: %s\n", e.Offset, e.Error())
        case *json.UnmarshalTypeError:
            fmt.Printf("类型错误，字段 %s，期望 %s，实际 %s\n", 
                e.Field, e.Type, e.Value)
        default:
            fmt.Printf("其他错误: %s\n", err)
        }
        return
    }
    fmt.Println("解析成功:", user)
}

七、性能优化：大数据量时的处理技巧

当你处理几MB的JSON数据时，直接Unmarshal可能会让内存爆炸。这时候该请出json.Decoder了：

func processLargeJSON() {
    // 模拟从文件或网络读取大数据
    jsonData := `{"data": "很大很大的JSON..."}`
    
    reader := strings.NewReader(jsonData)
    decoder := json.NewDecoder(reader)
    
    var result map[string]interface{}
    if err := decoder.Decode(&result); err != nil {
        panic(err)
    }
    
    // 流式处理，内存友好
    fmt.Println("处理完成")
}

八、实战：完整的企业级示例

来个综合案例，假设我们要处理电商订单：

package main

import (
    "encoding/json"
    "fmt"
    "time"
)

type Order struct {
    OrderID     string    `json:"order_id"`
    CreatedAt   string    `json:"created_at"` // 实际项目建议用time.Time
    TotalAmount float64   `json:"total_amount"`
    Items       []Item    `json:"items"`
    Customer    Customer  `json:"customer"`
}

type Item struct {
    SKU      string  `json:"sku"`
    Name     string  `json:"name"`
    Quantity int     `json:"quantity"`
    Price    float64 `json:"price"`
}

type Customer struct {
    ID    int    `json:"id"`
    Name  string `json:"name"`
    Phone string `json:"phone,omitempty"`
}

func main() {
    jsonData := `{
        "order_id": "20231234001",
        "created_at": "2023-12-25 14:30:00",
        "total_amount": 158.50,
        "items": [
            {
                "sku": "PROD001",
                "name": "Go语言编程实战",
                "quantity": 2,
                "price": 59.75
            },
            {
                "sku": "PROD002", 
                "name": "JSON解析指南",
                "quantity": 1,
                "price": 39.00
            }
        ],
        "customer": {
            "id": 1001,
            "name": "程序员老张"
        }
    }`

    var order Order
    if err := json.Unmarshal([]byte(jsonData), &order); err != nil {
        fmt.Printf("解析失败: %v\n", err)
        return
    }

    fmt.Printf("订单ID: %s\n", order.OrderID)
    fmt.Printf("总金额: ￥%.2f\n", order.TotalAmount)
    fmt.Printf("商品数量: %d\n", len(order.Items))
    
    totalItems := 0
    for _, item := range order.Items {
        totalItems += item.Quantity
        fmt.Printf(" - %s × %d = ￥%.2f\n", item.Name, item.Quantity, 
            float64(item.Quantity)*item.Price)
    }
    fmt.Printf("商品总件数: %d\n", totalItems)
}

这个例子几乎包含了所有你会遇到的场景：嵌套结构、数组、可选字段、浮点数计算等等。

九、避坑指南：血泪教训总结

数字类型陷阱：JSON里所有数字默认都是float64，往int转要小心精度丢失
时间格式：Go的time.Time不是JSON标准，需要自定义序列化
空值处理：用指针字段处理可能为null的值
内存泄露：大JSON解析完记得及时释放

// 处理可能为null的字段
type SafeStruct struct {
    OptionalField *string `json:"optional_field"`
}

十、总结

JSON解析看起来简单，但真要玩得转还是需要下点功夫的。记住几个核心要点：

结构体标签是灵魂，一定要写对
错误处理不能偷懒，特别是生产环境
大文件用Decoder，小数据用Unmarshal
不确定结构先用interface{}探路

现在你是不是对Go的JSON解析更有信心了？赶紧打开IDE，把上面的例子敲一遍，包你功力大涨！

（注：本文所有代码均在Go 1.19+ 测试通过，可直接使用）