一、Go解析Json数组
Json数组是一组有序的值序列，使用方括号[]来表示。在Go语言中，如果想要解析Json数组，只需要使用json.Unmarshal()即可。
package main
import (
"encoding/json"
"fmt"
)
type Person struct {
Name string
Age int
}
func main() {
var persons []Person
jsonStr := `[{"Name": "Alice","Age": 20},{"Name": "Bob","Age":22}]`
if err := json.Unmarshal([]byte(jsonStr), &persons); err != nil {
fmt.Println(err)
return
}
fmt.Println(persons)
}
在上述代码中，首先定义了一个Person结构体，包括Name和Age两个字段。接着定义了一个persons切片，用于存储解析后的Json数组。然后，使用json.Unmarshal()方法将Json字符串解析为persons切片，如果解析失败，输出错误信息。最后，打印解析后的persons切片。
需要注意的是，Go语言的json.Unmarshal()方法需要传入Json字符串的字节切片以及目标数据结构的指针。
二、Go解析Json对象数组
Json对象数组是一组由键值对组成的Json对象序列，使用花括号{}来表示。在Go语言中，如果想要解析Json对象数组，同样可以使用json.Unmarshal()方法。
package main
import (
"encoding/json"
"fmt"
)
type Person struct {
Name string
Age int
}
func main() {
var persons map[string]Person
jsonStr := `{
"Alice": {"Name": "Alice","Age": 20},
"Bob": {"Name": "Bob","Age":22}
}`
if err := json.Unmarshal([]byte(jsonStr), &persons); err != nil {
fmt.Println(err)
return
}
fmt.Println(persons)
}
在上述代码中，定义了一个Person结构体和一个persons映射，用于存储解析后的Json对象数组。使用json.Unmarshal()方法将Json字符串解析为persons映射类型。如果解析失败，输出错误信息。最后，打印解析后的persons映射。
三、Go解析Json失败
在Go语言中，如果Json字符串格式不正确，使用json.Unmarshal()方法会返回解析错误。例如：
package main
import (
"encoding/json"
"fmt"
)
type Person struct {
Name string
Age int
}
func main() {
var persons []Person
jsonStr := `{"Name": "Alice","Age": 20},{"Name": "Bob","Age":22}}`
if err := json.Unmarshal([]byte(jsonStr), &persons); err != nil {
fmt.Println(err)
return
}
fmt.Println(persons)
}
在上述代码中，Json字符串中的花括号不匹配，导致json.Unmarshal()方法抛出错误。
四、Go解析Json的方法
在Go语言中，解析Json字符串有多种方式。除了在前三个小标题中提到的json.Unmarshal()方法外，还有json.Decoder和json.Encoder方法。
1、json.Decoder方法
json.Decoder方法是一种基于流的Json解析方式，主要用于逐个Json值读取，适用于大型Json文件解析。
package main
import (
"encoding/json"
"fmt"
"strings"
)
type Person struct {
Name string
Age int
}
func main() {
var persons []Person
jsonStr := `[{"Name": "Alice","Age": 20},{"Name": "Bob","Age":22}]`
decoder := json.NewDecoder(strings.NewReader(jsonStr))
_, err := decoder.Token()
if err != nil {
fmt.Println(err)
}
for decoder.More() {
var person Person
if err := decoder.Decode(&person); err != nil {
fmt.Println(err)
return
}
persons = append(persons, person)
}
fmt.Println(persons)
}
在上述代码中，首先定义了一个Person结构体和一个persons切片，用于存储解析后的Json数组。然后，使用strings.NewReader()方法创建一个Reader对象，创建json.Decoder对象，从中读取Token。接着，使用decoder.More()方法判断是否有下一个Json值。如果有，使用decoder.Decode()方法解析Json值为Person结构体。然后，将解析后的Person结构体添加到persons切片中。
2、json.Encoder方法
json.Encoder方法是一种基于流的Json编码方式，主要用于逐个Json值写入到一个流中，适用于处理大型Json文件。
package main
import (
"encoding/json"
"fmt"
"os"
)
type Person struct {
Name string
Age int
}
func main() {
persons := []Person{{"Alice", 20}, {"Bob", 22}}
file, err := os.Create("example.json")
if err != nil {
fmt.Println(err)
return
}
defer file.Close()
encoder := json.NewEncoder(file)
if err := encoder.Encode(persons); err != nil {
fmt.Println(err)
return
}
fmt.Println("Json file created successfully")
}
在上述代码中，首先定义了一个persons切片，将解析后的Person结构体添加到此切片中。然后，使用os.Create()方法创建一个json文件，并创建json.Encoder对象，从中写入persons数据到文件中。
五、Go解析Json的性能
对于Json解析的性能问题，需要注意以下三点：
1、尽量不要使用json.Unmarshal()和json.Marshal()方法在高性能的应用程序中。
2、使用json.Decoder和json.Encoder方法的效率要高于Unmarshal和Marshal方法。如果要在高性能应用程序中进行Json解析，请考虑使用Decoder方法。
3、Json字符串解析耗费时间，因此，应尽量使用Json流解析。例如：使用json.Decoder方法的More()函数和Decoder()方法。
六、Go解析Json单引号
Go语言的json包默认只能解析双引号标记的Json字符串。如果要解析单引号标记的Json字符串，则需要进行一定的处理。可以使用替换函数，将Json字符串中的单引号转换为双引号，然后再进行解析。
package main
import (
"encoding/json"
"fmt"
"strings"
)
type Person struct {
Name string
Age int
}
func main() {
var persons []Person
jsonStr := `[
{'Name': 'Alice','Age': 20},
{'Name': 'Bob','Age':22}
]`
jsonStr = strings.Replace(jsonStr, "'", "\"", -1)
if err := json.Unmarshal([]byte(jsonStr), &persons); err != nil {
fmt.Println(err)
return
}
fmt.Println(persons)
}
在上述代码中，首先定义了一个Person结构体和一个persons切片，将解析后的Person结构体添加到persons切片中。然后，定义一个Json字符串，使用strings.Replace()函数，将Json字符串中的单引号替换成双引号。最后，使用json.Unmarshal()方法解析Json字符串。
七、Go解析Json字符串
在Go语言中，Json字符串解析需要使用json.Unmarshal()方法。需要注意的是，json.Unmarshal()方法只能解析成为基本数据类型或Struct结构体。如果要解析Json字符串中的嵌套Json，需要将其解析为字节切片，再次使用json.Unmarshal()方法进行解析。
package main
import (
"encoding/json"
"fmt"
)
type Person struct {
Name string
Age int
}
func main() {
var jsonString = `
{
"Name": "Alice",
"Age": 20,
"array": [1, 2, 3],
"nested": {
"Key": "value"
}
}
`
var person Person
if err := json.Unmarshal([]byte(jsonString), &person); err != nil {
fmt.Println("Json parsing error: ", err)
return
}
fmt.Println("Name: ", person.Name)
fmt.Println("Age: ", person.Age)
fmt.Println("Array: ", person.Array)
fmt.Println("Nested: ", person.Nested.Key)
}
在上述代码中，首先定义一个Json字符串，包括Name、Age、array和nested属性。然后定义一个Person结构体。使用json.Unmarshal()方法解析jsonString为Person结构体。最后，打印解析后的Person结构体。
八、Go解析Json的几种方式
除了在本文中介绍的Json解析方式，Go语言中还有其他多种Json解析方式，如下：
1、使用gojson方法解析Json字符串
GoJson方法是一种快速、简单的Json解析方式。它使用Go的struct将Json定义为强类型，同时能够在编译时生成解析代码，因此运行速度更快。
package main
import (
"fmt"
"github.com/ChimeraCoder/gojson"
)
func main() {
jsonStr := `{"Name": "Alice","Age": 20}`
obj, err := UnmarshalPerson([]byte(jsonStr))
if err != nil {
fmt.Println(err)
return
}
fmt.Println(obj)
}
type Person struct {
Name string `json:"Name"`
Age int `json:"Age"`
}
func UnmarshalPerson(data []byte) (Person, error) {
var r Person
err := gojson.Unmarshal(data, &r)
return r, err
}
在上述代码中，使用gojson将Person解析为强类型。首先定义一个Person结构体，使用json标记每个字段，以将Json属性映射到相应的struct字段。接着，定义UnmarshalPerson函数，使用gojson.Unmarshal()方法解析Json数据。
2、手动解析Json字符串
手动解析Json字符串是一种较为底层的Json解析方式。它基于Go语言的标准库，在解析Json字符串时，可以更精准地控制编码和解码过程，并可以支持更高效的解析方式。
package main
import (
"bytes"
"fmt"
)
type Person struct {
Name string `json:"Name"`
Age int `json:"Age"`
}
func Decode(data []byte) (*Person, error) {
var p Person
decoder := NewDecoder(bytes.NewBuffer(data))
for decoder.More() {
key, err := decoder.Token()
if err != nil {
return nil, err
}
switch key {
case "Name":
decoder.Decode(&p.Name)
case "Age":
decoder.Decode(&p.Age)
default:
continue
}
}
return &p, nil
}
func main() {
jsonStr := `{"Name": "Alice","Age": 20}`
obj, err := Decode([]byte(jsonStr))
if err != nil {
fmt.Println(err)
return
}
fmt.Println(obj)
}
在上述代码中，手动解析Json字符串需要使用Token和Decode方法，并通过for循环遍历每个token。在Decode方法中，首先定义一个Person结构体。然后，创建一个decoder对象，使用decoder.More()方法判断是否有下一个Json值。使用decoder.Token()方法获取Json Key，然后使用switch语句解析相应的值。最后返回Person结构体。
九、Go解析Json麻烦
Go解析Json在某些情况下可能会比较麻烦。例如，在解析Json字符串中的空字段时，可能会遇到一些困难。
package main
import (
"encoding/json"
"fmt"
)
type Person struct {
Name
原创文章，作者：小蓝，如若转载，请注明出处：https://www.506064.com/n/151590.html
微信扫一扫 
支付宝扫一扫 