Go JSON-Paket
Marshal(): Go-Datenobjekt -> >UnMarshal(): Json-Daten-> Go-Datenobjekt
JSON-Daten erstellenDie Funktionen Marshal() und MarshalIndent() können Kapseln Sie die Daten in JSON-Daten.
1. Struktur, Slice, Array, Karte können alle in JSON konvertiert werden2. Bei der Konvertierung von Struktur in JSON wird nur der erste Buchstabe des Feldes konvertiert 3. Beim Konvertieren der Karte muss der Schlüssel eine Zeichenfolge sein4 Wenn es sich bei der Kapselung um einen Zeiger handelt, wird das Objekt, auf das der Zeiger zeigt, verfolgt und gekapselt Zum Beispiel: Es gibt eine Strukturstruktur:
func Marshal(v interface{}) ([]byte, error)
func Unmarshal(data []byte, v interface{}) errortype Post struct {
Id int
Content string
Author string
}post := &Post{1, "Hello World", "userA"}
b, err := json.Marshal(post)
if err != nil {
fmt.Println(nil)
}fmt.Println(string(b))
{"Id":1,"Content":"Hello World","Author":"userA"}c,err := json.MarshalIndent(post,"","\t")
if err != nil {
fmt.Println(nil)
}
fmt.Println(string(c)){
"Id": 1,
"Content": "Hello World",
"Author": "userA"
}// slice -> json
s := []string{"a", "b", "c"}
d, _ := json.MarshalIndent(s, "", "\t")
fmt.Println(string(d))
// map -> json
m := map[string]string{
"a":"aa",
"b":"bb",
"c":"cc",
}
e,_ := json.MarshalIndent(m,"","\t")
fmt.Println(string(e))struct Bei den Feldern, die konvertiert werden können, handelt es sich um alle Felder, deren Anfangsbuchstaben großgeschrieben werden. Wenn Sie jedoch in JSON Schlüssel verwenden möchten, die mit Kleinbuchstaben beginnen, können Sie das Tag von struct verwenden, um die Reflexion zu unterstützen.
Zum Beispiel fügt die Post-Struktur ein Feld createAt mit einem kleingeschriebenen Anfangsbuchstaben hinzu.[
"a",
"b",
"c"
]
{
"a": "aa",
"b": "bb",
"c": "cc"
}type Post struct {
Id int `json:"ID"`
Content string `json:"content"`
Author string `json:"author"`
Label []string `json:"label"`
}
postp := &Post{
2,
"Hello World",
"userB",
[]string{"linux", "shell"},
}
p, _ := json.MarshalIndent(postp, "", "\t")
fmt.Println(string(p)){
"ID": 2,
"content": "Hello World",
"author": "userB",
"label": [
"linux",
"shell"
]
}Parsen Sie die JSON-Daten in eine Struktur (die Struktur ist bekannt)
JSON-Daten können in eine Struktur oder eine leere Schnittstelle interface{} analysiert werden (es können auch Slice, Map usw. sein). .). Nachdem Sie die Tag-Regeln beim Erstellen von JSON oben verstanden haben, ist es sehr einfach, JSON zu verstehen und zu analysieren.
Das Folgende ist beispielsweise ein JSON-Datenelement:type Post struct {
Id int `json:"ID,string"`
Content string `json:"content"`
Author string `json:"author"`
Label []string `json:"label,omitempty"`
}{
"id": 1,
"content": "hello world",
"author": {
"id": 2,
"name": "userA"
},
"published": true,
"label": [],
"nextPost": null,
"comments": [{
"id": 3,
"content": "good post1",
"author": "userB"
},
{
"id": 4,
"content": "good post2",
"author": "userC"
}
]
}type Post struct {
ID int64 `json:"id"`
Content string `json:"content"`
Author Author `json:"author"`
Published bool `json:"published"`
Label []string `json:"label"`
NextPost *Post `json:"nextPost"`
Comments []*Comment `json:"comments"`
}
type Author struct {
ID int64 `json:"id"`
Name string `json:"name"`
}
type Comment struct {
ID int64 `json:"id"`
Content string `json:"content"`
Author string `json:"author"`
}{1 hello world {2 userA} true [] <nil> [0xc042072300 0xc0420723c0]}也许你已经感受到了，从json数据反推算struct到底有多复杂，虽然逻辑不难，但如果数据复杂一点，这是件非常恶心的事情。所以，使用别人写好的工具来自动转换吧。本文后面有推荐json到数据结构的自动转换工具。
解析json到interface(结构未知)
上面是已知json数据结构的解析方式，如果json结构是未知的或者结构可能会发生改变的情况，则解析到struct是不合理的。这时可以解析到空接口interface{}或map[string]interface{}类型上，这两种类型的结果是完全一致的。
解析到interface{}上时，Go类型和JSON类型的对应关系如下
JSON类型 Go类型
---------------------------------------------
JSON objects <--> map[string]interface{}
JSON arrays <--> []interface{}
JSON booleans <--> bool
JSON numbers <--> float64
JSON strings <--> string
JSON null <--> nil例如：
func main() {
// 读取json文件
fh, err := os.Open("a.json")
if err != nil {
fmt.Println(err)
return
}
defer fh.Close()
jsonData, err := ioutil.ReadAll(fh)
if err != nil {
fmt.Println(err)
return
}
// 定义空接口接收解析后的json数据
var unknown interface{}
// 或：map[string]interface{} 结果是完全一样的
err = json.Unmarshal(jsonData, &unknown)
if err != nil {
fmt.Println(err)
return
}
fmt.Println(unknown)
}输出结果：
map[nextPost:<nil> comments:[map[id:3 content:good post1 author:userB] map[id:4 content:good post2 author:userC]] id:1 content:hello world author:map[id:2 name:userA] published:true label:[]]
上面将输出map结构。这是显然的，因为类型对应关系中已经说明了，json object解析到Go interface的时候，对应的是map结构。如果将上面输出的结构进行一下格式化，得到的将是类似下面的结构：
map[
nextPost:<nil>
comments:[
map[
id:3
content:good post1
author:userB
]
map[
id:4
content:good post2
author:userC
]
]
id:1
content:hello world
author:map[
id:2
name:userA
]
published:true
label:[]
]现在，可以从这个map中去判断类型、取得对应的值。但是如何判断类型？可以使用类型断言：
func main() {
// 读取json数据
fh, err := os.Open("a.json")
if err != nil {
fmt.Println(err)
return
}
defer fh.Close()
jsonData, err := ioutil.ReadAll(fh)
if err != nil {
fmt.Println(err)
return
}
// 解析json数据到interface{}
var unknown interface{}
err = json.Unmarshal(jsonData, &unknown)
if err != nil {
fmt.Println(err)
return
}
// 进行断言，并switch匹配
m := unknown.(map[string]interface{})
for k, v := range m {
switch vv := v.(type) {
case string:
fmt.Println(k, "type: string\nvalue: ", vv)
fmt.Println("------------------")
case float64:
fmt.Println(k, "type: float64\nvalue: ", vv)
fmt.Println("------------------")
case bool:
fmt.Println(k, "type: bool\nvalue: ", vv)
fmt.Println("------------------")
case map[string]interface{}:
fmt.Println(k, "type: map[string]interface{}\nvalue: ", vv)
for i, j := range vv {
fmt.Println(i,": ",j)
}
fmt.Println("------------------")
case []interface{}:
fmt.Println(k, "type: []interface{}\nvalue: ", vv)
for key, value := range vv {
fmt.Println(key, ": ", value)
}
fmt.Println("------------------")
default:
fmt.Println(k, "type: nil\nvalue: ", vv)
fmt.Println("------------------")
}
}
}结果如下：
comments type: []interface{}
value: [map[id:3 content:good post1 author:userB] map[author:userC id:4 content:good post2]]
0 : map[id:3 content:good post1 author:userB]
1 : map[id:4 content:good post2 author:userC]
------------------
id type: float64
value: 1
------------------
content type: string
value: hello world
------------------
author type: map[string]interface{}
value: map[id:2 name:userA]
name : userA
id : 2
------------------
published type: bool
value: true
------------------
label type: []interface{}
value: []
------------------
nextPost type: nil
value: <nil>
------------------可见，从interface中解析非常复杂，而且可能因为嵌套结构而导致无法正确迭代遍历。这时候，可以使用第三方包simplejson，见后文。
解析、创建json流
除了可以直接解析、创建json数据，还可以处理流式数据。
1、type Decoder解码json到Go数据结构
2、ype Encoder编码Go数据结构到json
例如：
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)
}输出：
Ed: Knock knock. Sam: Who's there? Ed: Go fmt. Sam: Go fmt who? Ed: Go fmt yourself!
再例如，从标准输入读json数据，解码后删除名为Name的元素，最后重新编码后输出到标准输出。
func main() {
dec := json.NewDecoder(os.Stdin)
enc := json.NewEncoder(os.Stdout)
for {
var v map[string]interface{}
if err := dec.Decode(&v); err != nil {
log.Println(err)
return
}
for k := range v {
if k != "Name" {
delete(v, k)
}
}
if err := enc.Encode(&v); err != nil {
log.Println(err)
}
}
}更多go语言知识请关注PHP中文网go语言教程栏目。
Das obige ist der detaillierte Inhalt vonSo verarbeiten Sie JSON-Daten in der Go-Sprache. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
Verwendung des Schlüsselworts Type in Go
So implementieren Sie eine verknüpfte Liste in Go
Was ist die Programmiersoftware für die Go-Sprache?
Wie man Go-Sprache von Grund auf lernt
Welche Methoden gibt es, um eine Operatorüberladung in der Go-Sprache zu implementieren?
Was sind die Operatoren in der Go-Sprache?
Die Rolle des Linux-Betriebssystems
Aktivierungscode für den Vista-Schlüssel
![[Web-Frontend] Node.js-Schnellstart](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
