How to read json in golang

Go language is a strongly typed programming language, often used for network programming and big data processing. As a lightweight data exchange format, JSON is widely used in data transmission and reception in network transmission. Reading JSON data is a very common task in Go language. Well, in this article, we will introduce how to use Golang to read JSON data.

1. Using JSON structures in Golang

In Golang, you can use structures to define the JSON format, and then you can use the json.Unmarshal() function to parse JSON data and implement JSON arrays of reading. The following code demonstrates how to read an array from JSON data.

package main
import (
    "encoding/json"
    "fmt"
)
type Book struct {
    Title  string `json:"title"`
    Author string `json:"author"`
    Price  string `json:"price"`
}
func main() {
    jsonData := `[{"title":"Golang实战开发","author":"张三","price":"100元"},
                  {"title":"深入浅出Go","author":"李四","price":"80元"}]`
    var books []Book
    json.Unmarshal([]byte(jsonData), &books)
    for _, book := range books {
        fmt.Println("Book Title: ", book.Title)
        fmt.Println("Book Author: ", book.Author)
        fmt.Println("Book Price: ", book.Price)
    }
}

In the above code, we first define a Book structure to represent the attribute information of each book. This structure uses json tag to bind JSON fields to ensure that we can read JSON data correctly.

Next, we demonstrate how to parse a JSON string into a Book type slice. In the code, we first create an empty slice to save the parsed data. We then call the json.Unmarshal() function, passing it the JSON data and a pointer to the empty slice we created. At this time, the function will automatically parse the JSON string and parse the data into a Book type slice.

Finally, we traverse the slice we just parsed and print the attribute information of each book to the terminal. When we run the program, we can see the following output:

Book Title:  Golang实战开发
Book Author:  张三
Book Price:  100元
Book Title:  深入浅出Go
Book Author:  李四
Book Price:  80元

2. Use Interface{} to read JSON data

In some scenarios, we do not know the location of the JSON data Specific structure, at this time, we can use variables of interface{} type to process JSON data. The following code demonstrates how to use the interface{} type to read a JSON object of unknown structure.

package main
import (
    "encoding/json"
    "fmt"
)
func main() {
    jsonData := `{"name":"张三","age":20}`
    var unknown map[string]interface{}
    json.Unmarshal([]byte(jsonData), &unknown)
    for key, value := range unknown {
        fmt.Printf("%v : %v
", key, value)
    }
}

In the above example, we use a map of interface{} type to receive JSON data of unknown structure, so that there is no need to define the structure in advance. json.Unmarshal()The function parses the JSON string into a map[string]interface{} type variable, and uses a for loop to traverse the variable and output its key and value respectively. When we run the program, we can see the following output:

name : 张三
age : 20

3. Use non-structural types to read JSON data

In addition, when we deal with small JSON objects or just need When reading some of the data, you may not need to define a structure first, but only need to define a value variable, and then parse the JSON string directly into the variable. The code below demonstrates how to read a JSON object using non-structure types.

package main
import (
    "encoding/json"
    "fmt"
)
func main() {
    jsonData := `{"name":"张三","age":20}`
    var unknown interface{}
    json.Unmarshal([]byte(jsonData), &unknown)
    m := unknown.(map[string]interface{})
    fmt.Println(m["name"], m["age"])
}

In the above code, we use a variable of type interface{} to receive JSON data and use type assertions to convert it to type map[string]interface{}. Then we took out the "name" and "age" fields in the map and printed the output.

When we run the program, we can see the following output:

张三 20

Summary

Reading JSON data in Golang is a very convenient thing. Using a structure to define the JSON format can make the program clearer. Using variables of the interface{} type can receive JSON data of unknown structure, while using non-structural types can simplify the code and improve the execution efficiency of the program. Of course, the above three methods of reading JSON data have their advantages and disadvantages, and we can flexibly choose the corresponding method according to different scenarios.

The above is the detailed content of How to read json in golang. For more information, please follow other related articles on the PHP Chinese website!