3. Unmarshal JSON

We can decode JSON bytes (or strings) into a Go struct using json.Unmarshal or a json.Decoder.

The Decode method of json.Decoder streams data from an io.Reader into a Go struct, while json.Unmarshal works with data that's already in []byte format. Using a json.Decoder can be more memory-efficient because it doesn't load all the data into memory at once. json.Unmarshal is ideal for small JSON data you already have in memory. When dealing with HTTP requests and responses, you will likely use json.Decoder since it works directly with an io.Reader.

Example

// res is an http.Response
defer res.Body.Close()

data, err := io.ReadAll(res.Body)
if err != nil {
	return nil, err
}

var issues []Issue
if err := json.Unmarshal(data, &issues); err != nil {
    return nil, err
}

Understanding Unmarshal vs Decoder

json.Decoder (streaming):

decoder := json.NewDecoder(res.Body)
decoder.Decode(&issues)

• Streams data directly from res.Body

• More memory efficient for large data

• Doesn't load everything into memory at once

json.Unmarshal (in-memory):

data, _ := io.ReadAll(res.Body)
json.Unmarshal(data, &issues)

• Reads all data into memory first as []byte

• Then unmarshals the bytes

• Better for small JSON already in memory

The Solution

func getIssues(url string) ([]Issue, error) {
	// Make HTTP request
	res, err := http.Get(url)
	if err != nil {
		return nil, err
	}
	defer res.Body.Close()
	
	// Read all data from response body into bytes
	data, err := io.ReadAll(res.Body)
	if err != nil {
		return nil, err
	}
	
	// Create slice to hold decoded issues
	var issues []Issue
	
	// Unmarshal JSON bytes into issues slice
	if err := json.Unmarshal(data, &issues); err != nil {
		return nil, err
	}
	
	return issues, nil
}

Step-by-Step Breakdown

1

Change Return Type

func getIssues(url string) ([]Issue, error)
//                         ^^^^^^^^
//                         Return slice of Issue instead of []byte

2

Function Name Changed

func getIssues(url string)
//   ^^^^^^^^^
//   Changed from getIssueData

3

Read Response Body

data, err := io.ReadAll(res.Body)
//   ^^^^                ^^^^^^^^
//    |                      |
// []byte              Read all bytes from response

This converts the stream into a byte slice.

4

Create Issues Slice

var issues []Issue

Empty slice that will be filled with unmarshaled data.

5

Unmarshal JSON

json.Unmarshal(data, &issues)
//             ^^^^  ^^^^^^^
//              |       |
//          JSON bytes  Where to put decoded data

• Takes []byte of JSON

• Decodes into &issues (address so it can modify)

6

Return Issues

return issues, nil

Return the decoded slice and no error.

Complete Working Code

package main

import (
	"encoding/json"
	"io"
	"net/http"
)

type Issue struct {
	Id       string `json:"id"`
	Title    string `json:"title"`
	Estimate int    `json:"estimate"`
}

func getIssues(url string) ([]Issue, error) {
	res, err := http.Get(url)
	if err != nil {
		return nil, err
	}
	defer res.Body.Close()
	
	data, err := io.ReadAll(res.Body)
	if err != nil {
		return nil, err
	}
	
	var issues []Issue
	if err := json.Unmarshal(data, &issues); err != nil {
		return nil, err
	}
	
	return issues, nil
}

The Flow

HTTP Response ↓ res.Body (stream of bytes) ↓ io.ReadAll() → data []byte (all bytes in memory) ↓ json.Unmarshal(data, &issues) → []Issue (Go structs) ↓ return issues

Comparison: Decoder vs Unmarshal

Using Decoder (from previous lesson)

func getIssues(url string) ([]Issue, error) {
	res, _ := http.Get(url)
	defer res.Body.Close()
	
	var issues []Issue
	decoder := json.NewDecoder(res.Body)
	decoder.Decode(&issues)
	
	return issues, nil
}

Using Unmarshal (this lesson)

func getIssues(url string) ([]Issue, error) {
	res, _ := http.Get(url)
	defer res.Body.Close()
	
	data, _ := io.ReadAll(res.Body)
	
	var issues []Issue
	json.Unmarshal(data, &issues)
	
	return issues, nil
}

Both accomplish the same thing!

When to Use Each

Use Decoder when:

• Working with streams (HTTP responses, files)

• Want memory efficiency

• Processing large JSON

Use Unmarshal when:

• JSON is already in []byte format

• Working with small JSON

• Need to do something with raw bytes first

Key Takeaways

• io.ReadAll reads entire response into []byte

• json.Unmarshal decodes []byte into structs

• &issues passes address so Unmarshal can modify it

• Return []Issue instead of []byte to give decoded data

Assignment

Update the getIssueData function in http.go.

1

Change the return signature to return []Issue instead of []byte.

2

Because the function will now return a decoded slice of issues, change the name from getIssueData to getIssues.

3

Get the data from the response body using io.ReadAll, creating a slice of bytes []byte.

4

Create a nil slice of issues []Issue.

5

Use json.Unmarshal on the data to get the JSON data.

6

Return the issues.

Solution

package main

import (
	"encoding/json"
	"fmt"
	"io"
	"net/http"
)

func getIssueData(url string) ([]byte, error) {
	res, err := http.Get(url)
	if err != nil {
		return nil, fmt.Errorf("error creating request: %w", err)
	}
	defer res.Body.Close()

	// SOLUTION BELOW
	
	data, err := io.ReadAll(res.Body)
	if err != nil{
		return nil, err
	}
	
	var issues []Issue
	if err := json.Unmarshal(data, &issues); err!=nil{
		return nil, err
	}

	return issues, nil
}

(Note: the solution illustrates the required changes — updating the return type/name and using io.ReadAll + json.Unmarshal to return a decoded []Issue.)