JSON Handling in Go

# CHAPTER 22

JSON Handling in Go #

1. Introduction #

2. Learning Objectives #

• Convert a Go Struct into a JSON string (Marshal).

• Convert a JSON string into a Go Struct (Unmarshal).

• Understand and apply Struct Tags.

• Handle unknown JSON structures.

3. Struct Tags (The Secret Ingredient) #

To bridge this gap, Go uses Struct Tags. These are backtick-quoted strings placed after the struct field. They tell the JSON encoder exactly how to format the keys.

type User struct {
    // Go sees 'ID', but JSON will see 'id'
    ID        int    `json:"id"`
    
    // JSON will see 'first_name'
    FirstName string `json:"first_name"`
    
    // omitempty means: If this is empty, don't include it in the JSON at all
    Email     string `json:"email,omitempty"`
    
    // A dash means: NEVER include this in JSON (Great for passwords!)
    Password  string `json:"-"`
}

4. Encoding (Marshaling) to JSON #

package main

import (
    "encoding/json"
    "fmt"
)

func main() {
    u := User{
        ID:        1,
        FirstName: "Alice",
        Password:  "supersecret", // This will be hidden!
    }

    // Marshal returns ([]byte, error)
    jsonData, err := json.Marshal(u)
    if err != nil {
        fmt.Println("Error marshaling JSON:", err)
        return
    }

    // Convert bytes to string for printing
    fmt.Println(string(jsonData))
}

Output: {"id":1,"first_name":"Alice"} *(Notice how the Email was omitted, the Password was hidden, and the keys are lowercase!)*

5. Decoding (Unmarshaling) from JSON #

Critical Memory Rule: You must pass a Pointer (&) of your struct to Unmarshal, so it can write the parsed data directly into your variable's memory address!

func main() {
    // Incoming JSON from the internet
    jsonString := `{"id": 42, "first_name": "Bob", "email": "bob@test.com"}`
    
    // Prepare an empty Go struct
    var newUser User

    // Unmarshal requires a slice of bytes, and a POINTER to the struct
    err := json.Unmarshal([]byte(jsonString), &newUser)
    
    if err != nil {
        fmt.Println("Error parsing JSON:", err)
        return
    }

    fmt.Printf("Successfully parsed! User %s has email %s\n", newUser.FirstName, newUser.Email)
}

6. Dealing with Unknown JSON (Unstructured Data) #

func main() {
    rawJson := `{"status": "success", "data": 100}`
    
    var result map[string]interface{}
    json.Unmarshal([]byte(rawJson), &result)
    
    fmt.Println("Status:", result["status"])
}

*(Note: While this works, using strongly-typed Structs is always preferred in Go for performance and safety).*

7. Common Mistakes #

• Unexported Struct Fields: If your struct field is lowercase (name string instead of Name string), the json package (which is an external package) cannot see it. It will silently ignore the field, and your generated JSON will be mysteriously empty. Always capitalize struct fields used for JSON!

• Forgetting the Pointer in Unmarshal: Calling json.Unmarshal(data, newUser) instead of &newUser. Go will return an error because it cannot modify a copy of the struct.

8. Best Practices #

• Pretty Print: If you are debugging and want human-readable JSON with indents and newlines, use json.MarshalIndent(u, "", " ") instead of standard Marshal.

9. Exercises #

1. 1. Create a Product struct with Name, Price, and InStock fields. Use struct tags to make them lowercase in JSON.

1. 2. Instantiate a Product, Marshal it to JSON, and print the resulting string.

10. MCQs with Answers & Explanations #

1. 1. Why must struct fields be capitalized to be converted to JSON? (Answer: Because the encoding/json package is an external package, and Go's visibility rules state that only capitalized fields are exported/visible outside the package).

1. 2. How do you exclude a field from being marshaled into JSON? (Answer: Using the json:"-" struct tag).