Go JSON 与编码

package main

import (
	"encoding/json"
	"fmt"
)

type Person struct {
	Name    string
	Age     int
	Email   string
	Hobbies []string
}

func main() {
	p := Person{
		Name:    "张三",
		Age:     28,
		Email:   "zhangsan@example.com",
		Hobbies: []string{"编程", "阅读", "游泳"},
	}

	// 基本编码
	data, err := json.Marshal(p)
	if err != nil {
		fmt.Println("编码失败:", err)
		return
	}
	fmt.Println("JSON:", string(data))

	// 格式化输出（带缩进）
	pretty, err := json.MarshalIndent(p, "", "  ")
	if err != nil {
		fmt.Println("编码失败:", err)
		return
	}
	fmt.Println("格式化 JSON:\n", string(pretty))

	// 编码 map
	m := map[string]interface{}{
		"name": "李四",
		"age":  30,
		"active": true,
	}
	mapData, _ := json.MarshalIndent(m, "", "  ")
	fmt.Println("\nMap JSON:\n", string(mapData))
}

package main

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

type User struct {
	Name  string `json:"name"`
	Age   int    `json:"age"`
	Email string `json:"email,omitempty"`
}

func main() {
	jsonStr := `{"name": "王五", "age": 25, "email": "wangwu@example.com"}`

	// 解码到结构体
	var user User
	err := json.Unmarshal([]byte(jsonStr), &user)
	if err != nil {
		fmt.Println("解码失败:", err)
		return
	}
	fmt.Printf("用户: %+v\n", user)

	// 解码到 map（适用于结构未知的 JSON）
	var result map[string]interface{}
	json.Unmarshal([]byte(jsonStr), &result)
	fmt.Printf("Name: %v, Age: %v\n", result["name"], result["age"])
	// 注意：数字会被解码为 float64

	// 解码到 interface{}（使用 json.Number 保留数字精度）
	decoder := json.NewDecoder(strings.NewReader(jsonStr))
	decoder.UseNumber()
	var generic interface{}
	decoder.Decode(&generic)
	m := generic.(map[string]interface{})
	fmt.Printf("Age type: %T, value: %v\n", m["age"], m["age"])
}

package main

import (
	"encoding/json"
	"fmt"
)

type Product struct {
	ID       int      `json:"id"`
	Name     string   `json:"name"`
	Price    float64  `json:"price"`
	Desc     string   `json:"description,omitempty"` // 空字符串时省略
	Internal string   `json:"-"`                      // 永远不序列化
	Tags     []string `json:"tags,omitempty"`          // nil 或空切片时省略
}

func main() {
	p := Product{
		ID:       1,
		Name:     "Go 语言编程",
		Price:    59.9,
		Desc:     "",  // 空字符串，omitempty 会省略此字段
		Internal: "内部编号", // json:"-" 不会被序列化
		Tags:     nil,
	}

	data, _ := json.MarshalIndent(p, "", "  ")
	fmt.Println(string(data))
	// 输出中没有 description、Internal 和 tags 字段

	// 带值的版本
	p2 := Product{
		ID:    2,
		Name:  "Go 并发编程",
		Price: 79.9,
		Desc:  "深入理解 Go 并发模型",
		Tags:  []string{"并发", "高级"},
	}

	data2, _ := json.MarshalIndent(p2, "", "  ")
	fmt.Println("\n", string(data2))
}

package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"strings"
)

type LogEntry struct {
	Level   string `json:"level"`
	Message string `json:"message"`
}

func main() {
	// === Encoder 流式编码 ===
	var buf bytes.Buffer
	encoder := json.NewEncoder(&buf)
	encoder.SetIndent("", "  ") // 可选：设置缩进

	entries := []LogEntry{
		{Level: "INFO", Message: "服务启动"},
		{Level: "WARN", Message: "内存使用率较高"},
		{Level: "ERROR", Message: "数据库连接失败"},
	}

	for _, entry := range entries {
		if err := encoder.Encode(entry); err != nil {
			fmt.Println("编码失败:", err)
		}
	}
	fmt.Println("编码结果:\n", buf.String())

	// === Decoder 流式解码 ===
	jsonStream := `{"level":"INFO","message":"请求处理"}
{"level":"DEBUG","message":"缓存命中"}
{"level":"ERROR","message":"超时"}`

	decoder := json.NewDecoder(strings.NewReader(jsonStream))
	for decoder.More() {
		var entry LogEntry
		if err := decoder.Decode(&entry); err != nil {
			fmt.Println("解码失败:", err)
			break
		}
		fmt.Printf("[%s] %s\n", entry.Level, entry.Message)
	}
}