Go语言 encoding/json包
Go语言自带的 JSON转换库
func Marshal(v interface{}) ([]byte, error)
把对象转换为JSON 布尔型转换为 JSON 后仍是布尔型 如 true -> true
浮点型 和 整数型转换后为 JSON里面的 常规数字 如 1.23 -> 1.23
字符串 将 以UTF-8编码转化输出为 Unicode字符集的字符串 特殊字符比如 <将会被转义为 \u003c
数组 和 切片被转换为JSON 里面的数组 []byte 类 会被转换为base64编码后的字符串 slice 的零值被转换为null
结构体 转化为 JSON对象 且 只有结构体里边以 大写字母开头 的可被导出的字段才会被转化输出 而这些可导出的字段会作为JSON对象的字符串索引
转化 map 类型的数据结构时 该数据的类型必须是 map[string]T(T 可以是 encoding/json 包支持的任意数据类型)
package main
import (
"encoding/json"
"fmt"
"os"
)
func main() {
type ColorGroup struct {
ID int
Name string
Colors []string
}
group := ColorGroup{
ID: 1,
Name: "Reds",
Colors: []string{"Crimson", "Red", "Ruby", "Maroon"},
}
b, err := json.Marshal(group)
if err != nil {
fmt.Println("error:", err)
}
os.Stdout.Write(b)
}//输出 {“ID”:1,”Name”:”Reds”,”Colors”:[“Crimson”,”Red”,”Ruby”,”Maroon”]}
func Unmarshal(data [] byte, v interface{}) error
把 JSON 转换回对象 把传入的 data 作为 JSON 解析 解析后的数据存 在参数 v 中
参数 v 是类型任意 (但一定是一个类型的指针)
原因是 在是以此函数进行JSON 解析的时候 函数不知道 传入参数的具体类型 所以 需要接收所有的类型
package main
import (
"encoding/json"
"fmt"
)
func main() {
var jsonBlob = []byte(`[
{"Name": "Platypus", "Order": "Monotremata"},
{"Name": "Quoll", "Order": "Dasyuromorphia"}
]`)
type Animal struct {
Name string
Order string
}
var animals []Animal
err := json.Unmarshal(jsonBlob, &animals)
if err != nil {
fmt.Println("error:", err)
}
fmt.Printf("%+v", animals)
}
输出 [{Name:Platypus Order:Monotremata} {Name:Quoll Order:Dasyuromorphia}]
Encoders and Decoders
NewDecoder returns a new decoder that reads from r.
func NewDecoder(r io.Reader) *Decoder
A Decoder reads and decodes JSON values from an input stream.
type Decoder struct {
// contains filtered or unexported fields
}
An Encoder writes JSON values to an output stream.
type Encoder struct {
// contains filtered or unexported fields
}
package main
import (
"encoding/json"
"fmt"
"io"
"log"
"strings"
)
func main() {
const jsonStream = `
{"Name": "Ed", "Text": "Knock knock."}
{"Name": "Sam", "Text": "Who's there?"}
{"Name": "Ed", "Text": "Go fmt."}
{"Name": "Sam", "Text": "Go fmt who?"}
{"Name": "Ed", "Text": "Go fmt yourself!"}
`
type Message struct {
Name, Text string
}
dec := json.NewDecoder(strings.NewReader(jsonStream))
for {
var m Message
if err := dec.Decode(&m); err == io.EOF {
break
} else if err != nil {
log.Fatal(err)
}
fmt.Printf("%s: %s\n", m.Name, m.Text)
}
}
Encode 和 Marshal 区别
func Encode is a method on an Encoder which writes JSON encoded Go types to an output stream (func NewEncoder takes an io.Writer and returns a *Encoder)
Marshal is a function that returns JSON encoding of Go types
package main
import (
"encoding/json"
"fmt"
"os"
)
// We'll use these two structs to demonstrate encoding and decoding of custom types below.
type Response1 struct {
Page int
Fruits []string
}
type Response2 struct {
Page int `json:"page"`
Fruits []string `json:"fruits"`
}
func main() {
// First we'll look at encoding basic data types to JSON strings. Here are some examples for atomic values
bolB, _ := json.Marshal(true)
fmt.Println(string(bolB))
intB, _ := json.Marshal(1)
fmt.Println(string(intB))
fltB, _ := json.Marshal(2.34)
fmt.Println(string(fltB))
strB, _ := json.Marshal("gopher")
fmt.Println(string(strB))
// And here are some for slices and maps, which encode
// to JSON arrays and objects as you'd expect.
slcD := []string{"apple", "peach", "pear"}
slcB, _ := json.Marshal(slcD)
fmt.Println(string(slcB))
mapD := map[string]int{"apple": 5, "lettuce": 7}
mapB, _ := json.Marshal(mapD)
fmt.Println(string(mapB))
// The JSON package can automatically encode your custom data types. It will only include exported
// fields in the encoded output and will by default use those names as the JSON keys.
res1D := &Response1{
Page: 1,
Fruits: []string{"apple", "peach", "pear"}}
res1B, _ := json.Marshal(res1D)
fmt.Println(string(res1B))
// You can use tags on struct field declarations to customize the encoded JSON key names. Check the
// definition of `Response2` above to see an example of such tags.
res2D := &Response2{
Page: 1,
Fruits: []string{"apple", "peach", "pear"}}
res2B, _ := json.Marshal(res2D)
fmt.Println(string(res2B))
// Now let's look at decoding JSON data into Go values. Here's an example for a generic data structure.
byt := []byte(`{"num":6.13,"strs":["a","b"]}`)
// We need to provide a variable where the JSON package can put the decoded data.
// This `map[string]interface{}` will hold a map of strings to arbitrary data types.
var dat map[string]interface{}
// Here's the actual decoding, and a check for associated errors.
if err := json.Unmarshal(byt, &dat); err != nil {
panic(err)
}
fmt.Println(dat)
// In order to use the values in the decoded map, we'll need to cast them to their appropriate type.
// For example here we cast the value in `num` to the expected `float64` type.
num := dat["num"].(float64)
fmt.Println(num)
// Accessing nested data requires a series of casts.
strs := dat["strs"].([]interface{})
str1 := strs[0].(string)
fmt.Println(str1)
// We can also decode JSON into custom data types. This has the advantages of adding additional type-safety to our programs and eliminating the
// need for type assertions when accessing the decoded data.
str := `{"page": 1, "fruits": ["apple", "peach"]}`
res := Response2{}
json.Unmarshal([]byte(str), &res)
fmt.Println(res)
fmt.Println(res.Fruits[0])
// In the examples above we always used bytes and strings as intermediates between the data and JSON representation on standard out. We can also
// stream JSON encodings directly to `os.Writer`s like `os.Stdout` or even HTTP response bodies.
enc := json.NewEncoder(os.Stdout)
d := map[string]int{"apple": 5, "lettuce": 7}
enc.Encode(d)
}
Go语言自带的 JSON转换库
func Marshal(v interface{}) ([]byte, error)
把对象转换为JSON 布尔型转换为 JSON 后仍是布尔型 如 true -> true
浮点型 和 整数型转换后为 JSON里面的 常规数字 如 1.23 -> 1.23
字符串 将 以UTF-8编码转化输出为 Unicode字符集的字符串 特殊字符比如 <将会被转义为 \u003c
数组 和 切片被转换为JSON 里面的数组 []byte 类 会被转换为base64编码后的字符串 slice 的零值被转换为null
结构体 转化为 JSON对象 且 只有结构体里边以 大写字母开头 的可被导出的字段才会被转化输出 而这些可导出的字段会作为JSON对象的字符串索引
转化 map 类型的数据结构时 该数据的类型必须是 map[string]T(T 可以是 encoding/json 包支持的任意数据类型)
package main
import (
"encoding/json"
"fmt"
"os"
)
func main() {
type ColorGroup struct {
ID int
Name string
Colors []string
}
group := ColorGroup{
ID: 1,
Name: "Reds",
Colors: []string{"Crimson", "Red", "Ruby", "Maroon"},
}
b, err := json.Marshal(group)
if err != nil {
fmt.Println("error:", err)
}
os.Stdout.Write(b)
}//输出 {“ID”:1,”Name”:”Reds”,”Colors”:[“Crimson”,”Red”,”Ruby”,”Maroon”]}
func Unmarshal(data [] byte, v interface{}) error
把 JSON 转换回对象 把传入的 data 作为 JSON 解析 解析后的数据存 在参数 v 中
参数 v 是类型任意 (但一定是一个类型的指针)
原因是 在是以此函数进行JSON 解析的时候 函数不知道 传入参数的具体类型 所以 需要接收所有的类型
package main
import (
"encoding/json"
"fmt"
)
func main() {
var jsonBlob = []byte(`[
{"Name": "Platypus", "Order": "Monotremata"},
{"Name": "Quoll", "Order": "Dasyuromorphia"}
]`)
type Animal struct {
Name string
Order string
}
var animals []Animal
err := json.Unmarshal(jsonBlob, &animals)
if err != nil {
fmt.Println("error:", err)
}
fmt.Printf("%+v", animals)
}
输出 [{Name:Platypus Order:Monotremata} {Name:Quoll Order:Dasyuromorphia}]
Encoders and Decoders
NewDecoder returns a new decoder that reads from r.
func NewDecoder(r io.Reader) *Decoder
A Decoder reads and decodes JSON values from an input stream.
type Decoder struct {
// contains filtered or unexported fields
}
An Encoder writes JSON values to an output stream.
type Encoder struct {
// contains filtered or unexported fields
}
package main
import (
"encoding/json"
"fmt"
"io"
"log"
"strings"
)
func main() {
const jsonStream = `
{"Name": "Ed", "Text": "Knock knock."}
{"Name": "Sam", "Text": "Who's there?"}
{"Name": "Ed", "Text": "Go fmt."}
{"Name": "Sam", "Text": "Go fmt who?"}
{"Name": "Ed", "Text": "Go fmt yourself!"}
`
type Message struct {
Name, Text string
}
dec := json.NewDecoder(strings.NewReader(jsonStream))
for {
var m Message
if err := dec.Decode(&m); err == io.EOF {
break
} else if err != nil {
log.Fatal(err)
}
fmt.Printf("%s: %s\n", m.Name, m.Text)
}
}
Encode 和 Marshal 区别
func Encode is a method on an Encoder which writes JSON encoded Go types to an output stream (func NewEncoder takes an io.Writer and returns a *Encoder)
Marshal is a function that returns JSON encoding of Go types
package main
import (
"encoding/json"
"fmt"
"os"
)
// We'll use these two structs to demonstrate encoding and decoding of custom types below.
type Response1 struct {
Page int
Fruits []string
}
type Response2 struct {
Page int `json:"page"`
Fruits []string `json:"fruits"`
}
func main() {
// First we'll look at encoding basic data types to JSON strings. Here are some examples for atomic values
bolB, _ := json.Marshal(true)
fmt.Println(string(bolB))
intB, _ := json.Marshal(1)
fmt.Println(string(intB))
fltB, _ := json.Marshal(2.34)
fmt.Println(string(fltB))
strB, _ := json.Marshal("gopher")
fmt.Println(string(strB))
// And here are some for slices and maps, which encode
// to JSON arrays and objects as you'd expect.
slcD := []string{"apple", "peach", "pear"}
slcB, _ := json.Marshal(slcD)
fmt.Println(string(slcB))
mapD := map[string]int{"apple": 5, "lettuce": 7}
mapB, _ := json.Marshal(mapD)
fmt.Println(string(mapB))
// The JSON package can automatically encode your custom data types. It will only include exported
// fields in the encoded output and will by default use those names as the JSON keys.
res1D := &Response1{
Page: 1,
Fruits: []string{"apple", "peach", "pear"}}
res1B, _ := json.Marshal(res1D)
fmt.Println(string(res1B))
// You can use tags on struct field declarations to customize the encoded JSON key names. Check the
// definition of `Response2` above to see an example of such tags.
res2D := &Response2{
Page: 1,
Fruits: []string{"apple", "peach", "pear"}}
res2B, _ := json.Marshal(res2D)
fmt.Println(string(res2B))
// Now let's look at decoding JSON data into Go values. Here's an example for a generic data structure.
byt := []byte(`{"num":6.13,"strs":["a","b"]}`)
// We need to provide a variable where the JSON package can put the decoded data.
// This `map[string]interface{}` will hold a map of strings to arbitrary data types.
var dat map[string]interface{}
// Here's the actual decoding, and a check for associated errors.
if err := json.Unmarshal(byt, &dat); err != nil {
panic(err)
}
fmt.Println(dat)
// In order to use the values in the decoded map, we'll need to cast them to their appropriate type.
// For example here we cast the value in `num` to the expected `float64` type.
num := dat["num"].(float64)
fmt.Println(num)
// Accessing nested data requires a series of casts.
strs := dat["strs"].([]interface{})
str1 := strs[0].(string)
fmt.Println(str1)
// We can also decode JSON into custom data types. This has the advantages of adding additional type-safety to our programs and eliminating the
// need for type assertions when accessing the decoded data.
str := `{"page": 1, "fruits": ["apple", "peach"]}`
res := Response2{}
json.Unmarshal([]byte(str), &res)
fmt.Println(res)
fmt.Println(res.Fruits[0])
// In the examples above we always used bytes and strings as intermediates between the data and JSON representation on standard out. We can also
// stream JSON encodings directly to `os.Writer`s like `os.Stdout` or even HTTP response bodies.
enc := json.NewEncoder(os.Stdout)
d := map[string]int{"apple": 5, "lettuce": 7}
enc.Encode(d)
}
尊贵的董事大人
英文标题不为空时 视为本栏投稿
需要关键字 描述 英文标题