2. Decoding JSON

When you receive JSON data in an HTTP response body, it's a stream of bytes. In Go it's common to decode that JSON directly into a struct (or slice of structs) using the standard encoding/json package rather than converting bytes to string.

Example JSON

[
  {
    "id": "001-a",
    "title": "Unspaghettify code",
    "estimate": 9001
  }
]

Struct with JSON tags

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

Notes about tags and exported fields

• The tag json:"id" maps the JSON id field to the Go field.

• Tags are wrapped in backticks `.

• Only exported (capitalized) fields are decoded. Unexported fields (lowercase) will be ignored by the decoder.

Decoding from an HTTP response body

// res is a successful `http.Response`

var issues []Issue
decoder := json.NewDecoder(res.Body)
if err := decoder.Decode(&issues); err != nil {
    fmt.Println("error decoding response body")
    return
}

Using the decoded data

for _, issue := range issues {
    fmt.Printf("Issue – id: %v, title: %v, estimate: %v\n", issue.Id, issue.Title, issue.Estimate)
    // Issue – id: 001-a, title: Unspaghettify code, estimate: 9001
}

Complete example

main.go

package main

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

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

func main() {
    // Make HTTP request
    res, err := http.Get("https://api.example.com/issues")
    if err != nil {
        fmt.Println("error making request")
        return
    }
    defer res.Body.Close()
    
    // Decode JSON response
    var issues []Issue
    decoder := json.NewDecoder(res.Body)
    if err := decoder.Decode(&issues); err != nil {
        fmt.Println("error decoding response")
        return
    }
    
    // Use the data
    for _, issue := range issues {
        fmt.Printf("Issue: %s - %s\n", issue.Id, issue.Title)
    }
}

JSON tag options

Field string `json:"field_name"`
Field string `json:"field_name,omitempty"` // omit when empty
Field string `json:"-"`                    // ignore field
Field string `json:",omitempty"`           // use Go field name as JSON key, omit when empty

Common patterns

• Single object: decode into a struct value.

• Array of objects: decode into a slice of structs.

• Nested objects: define nested struct types and decode accordingly.

Alternative: json.Unmarshal

jsonData := []byte(`{"name":"Alice","age":30}`)

type User struct {
    Name string `json:"name"`
    Age  int    `json:"age"`
}

var user User
err := json.Unmarshal(jsonData, &user)
if err != nil {
    fmt.Println("error unmarshaling")
}

When to use each:

• json.NewDecoder — for streams (HTTP responses, files)

• json.Unmarshal — for byte slices already in memory

Error handling example

if err := decoder.Decode(&issues); err != nil {
    switch err {
    case io.EOF:
        fmt.Println("empty response")
    default:
        fmt.Printf("decode error: %v\n", err)
    }
    return
}

Key takeaways:

• JSON tags map JSON fields to struct fields: json:"field_name"

• Fields must be exported (capitalized) to decode

• Use & when decoding so the decoder can modify the variable

• json.NewDecoder for streams, json.Unmarshal for byte slices

• Always check errors when decoding

Quick reference

// Define struct with tags
type Item struct {
    Field string `json:"json_field_name"`
}

// Decode from HTTP response
var items []Item
decoder := json.NewDecoder(res.Body)
err := decoder.Decode(&items)

// Or unmarshal from bytes
var items []Item
err := json.Unmarshal(jsonBytes, &items)

Assignment

Follow these steps to decode the response data directly into a slice of issues and return it. If any error occurs return a nil slice and the error.

1

Import the json package:

• add "encoding/json" to your imports

2

Create a nil slice of items:

• var issues []Issue

3

Create a new *json.Decoder using json.NewDecoder:

• decoder := json.NewDecoder(res.Body)

4

Decode the response body using Decode:

• if err := decoder.Decode(&issues); err != nil { return nil, err }

5

Return the slice of issues:

• return issues, nil

Solution example

get_issues.go

package main

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

func getIssues(url string) ([]Issue, error) {
    res, err := http.Get(url)
    if err != nil {
        return nil, fmt.Errorf("error creating request: %w", err)
    }
    defer res.Body.Close()
    
    // Solution Below
    var issues []Issue
    decoder := json.NewDecoder(res.Body)
    if err := decoder.Decode(&issues); err != nil {
        fmt.Println("error")
        return nil, err
    }

    return issues, nil
}