GO语方方处理JSON教程：Unmarshal解析JSON字符串

Unmarshal解析JSON字符串

package main

import (
    "encoding/json"
    "fmt"
)

// 准备解析结构体
type Person struct {
    Name string `json:"name"`
    Age  int    `json:"age"`
}

func main() {
    // 准备JSON数据
    data := `{"name":"zhangsan","age":33}`

    // 解析JSON字符串
    var p Person
    json.Unmarshal([]byte(data), &p)

    // 查看解析结果
    fmt.Println(p.Name, p.Age)
}

Marshal将对象转换为JSON字符串

package main

import (
    "encoding/json"
    "fmt"
)

// 准备解析结构体
type Person struct {
    Name string `json:"name"`
    Age  int    `json:"age"`
}

func main() {
    // 准备对象
    p := Person{
        Name: "zs",
        Age:  22,
    }

    // 将对象转换为JSON字符串
    data, err := json.Marshal(p)
    if err != nil {
        panic(err)
    }

    // 查看解析结果
    fmt.Println(string(data))
}

将对象保存为JSON文件

package main

import (
    "encoding/json"
    "os"
)

// 准备解析结构体
type Person struct {
    Name string `json:"name"`
    Age  int    `json:"age"`
}

func main() {
    // 准备对象
    p := Person{
        Name: "zs",
        Age:  22,
    }

    // 创建文件
    f, err := os.Create("tmp.json")
    if err != nil {
        panic(err)
    }

    // 写入JSON
    encodeJson := json.NewEncoder(f)
    err = encodeJson.Encode(p)
    if err != nil {
        panic(err)
    }
}

读取JSON文件为对象

package main

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

// 准备解析结构体
type Person struct {
    Name string `json:"name"`
    Age  int    `json:"age"`
}

func main() {
    // 打开文件
    f, err := os.Open("tmp.json")
    if err != nil {
        panic(err)
    }

    // 读取JSON
    decodeJson := json.NewDecoder(f)
    var p Person
    err = decodeJson.Decode(&p)
    if err != nil {
        panic(err)
    }

    // 查看读取结果
    fmt.Println(p.Name, p.Age)
}

封装便捷方法

通过前面的学习，我们应该能够掌握：

• 将Go对象转换为JSON字符串
• 将JSON字符串转换为Go对象
• 将Go对象保存为JSON文件
• 将JSON文件加载为Go对象

有了这四个核心功能以后，我们可以进行简单的封装，可以设计如下方法：

• toJson：将Go对象转换为JSON字符串
• fromJson：将JSON字符串转换为Go对象
• writeJson：将Go对象保存为JSON文件
• readJson：将JSON文件读取为Go对象

示例代码：

package main

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

// 准备解析结构体
type Person struct {
    Name string `json:"name"`
    Age  int    `json:"age"`
}

// ● toJson：将Go对象转换为JSON字符串
func toJson(obj interface{}) ([]byte, error) {
    return json.Marshal(obj)
}

// ● fromJson：将JSON字符串转换为Go对象
func fromJson(data string, obj interface{}) error {
    return json.Unmarshal([]byte(data), obj)
}

// ● writeJson：将Go对象保存为JSON文件
func writeJson(filename string, obj interface{}) error {
    // 创建文件
    f, err := os.Create(filename)
    if err != nil {
        return err
    }

    // 写入JSON
    encodeJson := json.NewEncoder(f)
    err = encodeJson.Encode(obj)
    if err != nil {
        return err
    }

    return nil
}

// ● readJson：将JSON文件读取为Go对象
func readJson(filename string, obj interface{}) error {
    // 打开文件
    f, err := os.Open(filename)
    if err != nil {
        return err
    }

    // 读取JSON
    decodeJson := json.NewDecoder(f)
    err = decodeJson.Decode(obj)
    if err != nil {
        return err
    }

    return nil
}

func main() {
    // 转换JSON字符串
    p := Person{
        Name: "zs",
        Age:  22,
    }
    v, _ := toJson(p)
    fmt.Println(string(v))

    // 读取JSON字符串
    var p1 Person
    _ = fromJson(string(v), &p1)
    fmt.Println(p1.Name, p1.Age)

    // 保存为JSON文件
    filename := "tmp1.json"
    _ = writeJson(filename, &p1)

    // 读取JSON文件
    var p2 Person
    _ = readJson(filename, &p2)
    fmt.Println(p2.Name, p2.Age)
}