4. Marshal JSON

If there is a way to unmarshal JSON data, there must be a way to marshal it as well. The json.Marshal function converts a Go struct into a slice of bytes representing JSON data.

Example

type Board struct {
	Id       int    `json:"id"`
	Name     string `json:"name"`
	TeamId   int    `json:"team"`
	TeamName string `json:"team_name"`
}

board := Board{
	Id:       1,
	Name:     "API",
	TeamId:   9001,
	TeamName: "Backend",
}

data, err := json.Marshal(board)
if err != nil {
	log.Fatal(err)
}
fmt.Println(string(data))
// {"id":1,"name":"API","team":9001,"team_name":"Backend"}

📦 The Simple Analogy

Think of JSON like a package you're shipping:

Marshaling = 📦 Packing (Go → JSON) Unmarshaling = 📭 Unpacking (JSON → Go)

---

🔄 Marshaling: Go Struct → JSON String

"Marshal" means converting Go data into JSON format (for sending/storing).

// You have a Go struct
type Person struct {
    Name string
    Age  int
}

person := Person{Name: "Alice", Age: 30}

// Marshal: Convert Go struct → JSON string
jsonData, _ := json.Marshal(person)

fmt.Println(string(jsonData))
// Output: {"Name":"Alice","Age":30}

Why? So you can:

• Send it over the network (APIs)

• Save it to a file

• Store it in a database

• Send it to a web browser

---

🔄 Unmarshaling: JSON String → Go Struct

"Unmarshal" means converting JSON into Go data (for reading/using).

// You receive JSON from somewhere
jsonString := `{"Name":"Bob","Age":25}`

// Unmarshal: Convert JSON string → Go struct
var person Person
json.Unmarshal([]byte(jsonString), &person)

fmt.Println(person.Name)  // "Bob"
fmt.Println(person.Age)   // 25

Why? So you can:

• Read data from an API response

• Load configuration from a file

• Process data sent from a web browser

• Work with the data in your Go code

---

📊 Visual Comparison

MARSHALING (Packing) Go Struct ──────────> JSON String

UNMARSHALING (Unpacking) JSON String ──────────> Go Struct

---

🎯 Real-World Example

Scenario: Sending an email

Step: Marshal (before sending)

type Email struct {
    To      string
    Subject string
    Body    string
}

email := Email{
    To:      "[e-mail]",
    Subject: "Hello",
    Body:    "How are you?",
}

// Pack it into JSON to send over HTTP
jsonData, _ := json.Marshal(email)
// Send jsonData over the network

Step: Unmarshal (when receiving)

// Receive JSON from the network
jsonString := `{"To":"[e-mail]","Subject":"Hello","Body":"How are you?"}`

// Unpack it into a Go struct to use
var receivedEmail Email
json.Unmarshal([]byte(jsonString), &receivedEmail)

// Now you can use it
fmt.Println(receivedEmail.To)      // "[e-mail]"
fmt.Println(receivedEmail.Subject) // "Hello"

---

🧠 Memory Trick

Marshal = Mar-ching out (Go → JSON, sending out) Unmarshal = Un-packing (JSON → Go, bringing in)

Or think of it as:

• Marshal = Make it transportable (like packing a suitcase)

• Unmarshal = Make it usable (like unpacking a suitcase)

---

📝 Quick Reference

Operation	Direction	Purpose	Example
Marshal	Go → JSON	Convert to send/store	json.Marshal(struct)
Unmarshal	JSON → Go	Convert to use in code	json.Unmarshal(json, &struct)

---

✅ Summary

• Marshal: Turn Go data into JSON (for sending/storing)

• Unmarshal: Turn JSON into Go data (for using in your code)

Think:

• Sending an email? Marshal it first

• Receiving an email? Unmarshal it to read

Assignment

Complete the marshalAll function. It accepts a slice of "items", which can be of any type. The expectation is that they are structs of various forms. It should return a slice of slices of bytes [][]byte.

1

Create a slice of byte slices to hold the marshalled data.

2

For each item in items:

• Marshal the item into a slice of bytes.

• If an item cannot be marshaled, immediately return a nil slice and the error.

• Add the marshalled JSON byte slice to the slice of bytes slices.

3

Return the marshalled data in the same order as the input items.

Solution

package main

import (
	"encoding/json"
)

func marshalAll[T any](items []T) ([][]byte, error) {
	
	// SOLUTION BELOW
	
	bs := make([][]byte, 0, len(items))

	for _, item := range items{
		data, err:= json.Marshal(item)
		if err != nil{
			return nil, err
		}
		bs = append(bs, data)
	}
	return bs, nil
	
}

Explanation of a key line:

bs := make([][]byte, 0, len(items))

• make creates a slice.

• [][]byte is the element type: a slice whose elements are []byte (each []byte will hold one marshaled JSON blob).

• The second argument 0 is the length: the slice starts empty, so len(bs) == 0.

• The third argument len(items) is the capacity: it pre-allocates space for that many elements, so appending up to len(items) times won’t need to grow the underlying array.

So you still append each data, but you avoid extra allocations/copies as the slice grows.