Welcome back! In the previous lesson, you learned how to encode Go structs into JSON format, a process known as marshaling. This skill is crucial for sending data to APIs, as JSON is the primary data format for most web services. Now, we will focus on the reverse process: decoding JSON data into Go structs, also known as unmarshaling. This is an essential skill for receiving and processing data from APIs. By the end of this lesson, you will be able to seamlessly convert JSON data into Go structs, preparing you for effective API communication.

When decoding JSON into Go structs, it's important to understand how JSON keys map to struct fields. In Go, this is achieved using struct tags. Struct tags are annotations that specify how struct fields should be encoded or decoded. For example, if you have a JSON key named "title," you can map it to a struct field using a tag like json:"title". This ensures that the JSON data is correctly mapped to the corresponding fields in your Go struct.

Let's walk through an example to see how decoding JSON into Go structs works in practice. We'll use the Todo struct, which you are already familiar with from previous lessons. Here's a complete example that demonstrates how to fetch JSON data from an API and decode it into a Go struct.

Go
Copy to clipboard
1type Todo struct {
2    Title       string `json:"title"`
3    Done        bool   `json:"done"`
4    Description string `json:"description"`
5}

The Todo struct defines the expected structure of the JSON data. The struct tags (json:"title", etc.) map the JSON keys to Go struct fields.

Go
Copy to clipboard
1func fetchTodos(url string) ([]byte, error) {
2    response, err := http.Get(url)
3    if err != nil {
4        return nil, fmt.Errorf("request to %s failed: %w", url, err)
5    }
6    defer response.Body.Close()
7
8    if response.StatusCode != http.StatusOK {
9        return nil, fmt.Errorf("request failed with status: %s", response.Status)
10    }
11
12    body, err := ioutil.ReadAll(response.Body)
13    if err != nil {
14        return nil, fmt.Errorf("failed to read response body: %w", err)
15    }
16    return body, nil
17}

This function fetches JSON data from the given API URL and returns the raw JSON response body.

Go
Copy to clipboard
1func parseTodos(data []byte) ([]Todo, error) {
2    var todos []Todo
3    err := json.Unmarshal(data, &todos)
4    if err != nil {
5        return nil, fmt.Errorf("JSON decoding failed: %w", err)
6    }
7    return todos, nil
8}

Here, we use json.Unmarshal to convert the JSON data into a slice of Todo structs.

Go
Copy to clipboard
1func printTodos(todos []Todo) {
2    fmt.Println("Decoded todo items from JSON:")
3    for _, todo := range todos {
4        fmt.Println("Title: ", todo.Title)
5        fmt.Println("Done: ", todo.Done)
6        fmt.Println("Description: ", todo.Description)
7        fmt.Println("-----------------------------")
8    }
9}

This function iterates over the parsed todos and prints each one.

Go
Copy to clipboard
1import (
2    "encoding/json"
3    "fmt"
4    "io"
5    "net/http"
6)
7
8func main() {
9    url := "http://localhost:8000/todos"
10    body, err := fetchTodos(url)
11    if err != nil {
12        fmt.Println(err)
13        return
14    }
15
16    todos, err := parseTodos(body)
17    if err != nil {
18        fmt.Println(err)
19        return
20    }
21
22    printTodos(todos)
23}

This is the main function that ties everything together. It fetches JSON data, parses it into Go structs, and prints the results.

When decoding JSON, it's important to handle potential errors effectively. Common errors include network issues, incorrect JSON structure, and mismatched struct fields. In the example above, we handle errors at each step of the process, from making the HTTP request to reading the response body and decoding the JSON. Proper error handling ensures that your application can gracefully handle unexpected situations and provides valuable feedback for debugging.

In this lesson, you learned how to decode JSON data into Go structs using the encoding/json package. We covered the process of making an HTTP GET request, reading the response body, and using json.Unmarshal to decode the JSON data. This knowledge is essential for receiving and processing data from APIs in Go applications. As you move on to the practice exercises, I encourage you to experiment with different JSON structures and decode them into structs. Mastering JSON decoding will enhance your ability to work with APIs and JSON data in Go. Keep practicing, and you'll be well-prepared for the next lesson on handling nested and optional JSON fields.