Chapter 11: Encoding and Decoding (JSON)

Introduksyon

Sige, ablihan nato ang topic about JSON — kana bitawng standard format nga ginagamit sa mga API sa web. Ang Go encoding/json package kay kompleto na: marshaling (Go values → JSON) ug unmarshaling (JSON → Go values). Sulit ra kaayo.

JSON

Ang JSON kay simple ra — key-value pairs ug arrays ray naa. Ang Go types diretso rag katapat sa JSON:

Go              JSON
string          string
int/float64     number
bool            boolean
nil             null
[]T             array
map[string]T    object
struct          object

Decoding JSON

Gamit ug json.Unmarshal para i-convert ang JSON bytes balik sa Go values. Siyay imong translator:

type Person struct {
    Name string
    Age  int
}

data := []byte(`{"Name":"Alice","Age":30}`)
var p Person
err := json.Unmarshal(data, &p)
if err != nil {
    log.Fatal(err)
}
fmt.Println(p.Name, p.Age)

Struct Tags

Ang struct tags kay murag label sa imong code — silay nagsulti kung unsa nga JSON field name ang katapat sa Go field. json:"name" para irename, omitempty para di mo-appear kung zero value, - para invisible jud:

type User struct {
    ID        int    `json:"id"`
    Name      string `json:"name"`
    Email     string `json:"email,omitempty"`
    Password  string `json:"-"`  // never serialized
}

u := User{ID: 1, Name: "Alice", Password: "secret"}
out, _ := json.Marshal(u)
fmt.Println(string(out))  // {"id":1,"name":"Alice"}

Exercise 11.01: Unmarshaling Student Courses

Goal: Kuhaa ang JSON sa estudyante (name + courses) ug i-parse into Go struct.

package main

import (
    "encoding/json"
    "fmt"
)

type Student struct {
    Name    string   `json:"name"`
    Courses []string `json:"courses"`
}

func main() {
    data := []byte(`{"name":"Alice","courses":["Math","Physics","CS"]}`)
    var s Student
    json.Unmarshal(data, &s)
    fmt.Printf("%s takes: %v\n", s.Name, s.Courses)
}

Encoding JSON

Si json.Marshal ang imong driver para iconvert Go values into JSON. Kung gusto ug neat na itsura, json.MarshalIndent ang gamita:

type Product struct {
    Name  string  `json:"name"`
    Price float64 `json:"price"`
    InStock bool  `json:"in_stock"`
}

p := Product{"Laptop", 999.99, true}
out, _ := json.Marshal(p)
fmt.Println(string(out))  // {"name":"Laptop","price":999.99,"in_stock":true}

pretty, _ := json.MarshalIndent(p, "", "  ")
fmt.Println(string(pretty))

Exercise 11.02: Marshaling Student Courses

Goal: Maghimo ug Student struct, butangan ug data, dayon i-marshal sa JSON.

package main

import (
    "encoding/json"
    "fmt"
)

type Student struct {
    Name    string   `json:"name"`
    Age     int      `json:"age"`
    Courses []string `json:"courses"`
    Active  bool     `json:"active"`
}

func main() {
    s := Student{
        Name:    "Bob",
        Age:     22,
        Courses: []string{"History", "English"},
        Active:  true,
    }
    data, _ := json.MarshalIndent(s, "", "  ")
    fmt.Println(string(data))
}

Unknown JSON Structures

Kung wa kay pakbaw sa structure sa JSON, gamit ug map[string]any or any. Flexible ra:

data := []byte(`{"name":"Alice","age":30,"metadata":{"role":"admin","since":2020}}`)
var result map[string]any
json.Unmarshal(data, &result)

fmt.Println(result["name"])                // Alice
fmt.Println(result["metadata"])            // map[role:admin since:2020]

// Access nested data
meta := result["metadata"].(map[string]any)
fmt.Println(meta["role"])                  // admin

Exercise 11.03: Analyzing College Class JSON

Goal: I-parse ang JSON array sa mga college classes nga lain-laig structure, dayon i-print ang class name.

package main

import (
    "encoding/json"
    "fmt"
)

func main() {
    data := []byte(`[
        {"code":"CS101","name":"Intro to CS","credits":3},
        {"code":"MATH200","name":"Calculus II","credits":4}
    ]`)

    var classes []map[string]any
    json.Unmarshal(data, &classes)

    for _, c := range classes {
        fmt.Println(c["code"], "-", c["name"])
    }
}

GOB: Go's Own Encoding

encoding/gob kay exclusive Go-to-Go binary format. Dili ni pwedeng gamiton sa Python o Java — Go ra gyud. Pero worth it kay efficient para RPC, disk storage, ug Go-to-Go communication:

import "encoding/gob"

type Data struct {
    Name  string
    Value int
}

// Encode
var buf bytes.Buffer
enc := gob.NewEncoder(&buf)
err := enc.Encode(Data{"key", 42})

// Decode
dec := gob.NewDecoder(&buf)
var decoded Data
dec.Decode(&decoded)

Exercise 11.04: Using gob to Encode Data

Goal: I-encode ang struct gamit gob into buffer, dayon i-decode balik. Simple ra.

package main

import (
    "bytes"
    "encoding/gob"
    "fmt"
)

type Person struct {
    Name string
    Age  int
}

func main() {
    var buf bytes.Buffer
    enc := gob.NewEncoder(&buf)

    alice := Person{"Alice", 30}
    enc.Encode(alice)

    var decoded Person
    dec := gob.NewDecoder(&buf)
    dec.Decode(&decoded)

    fmt.Printf("Decoded: %+v\n", decoded)
}

Activity 11.01: Mimicking a Customer Order Using JSON

Goal: Maghimo ug customer order struct, i-marshal sa JSON, dayon i-unmarshal balik. Mao ra nay rhythm.

package main

import (
    "encoding/json"
    "fmt"
)

type OrderItem struct {
    Product string  `json:"product"`
    Qty     int     `json:"qty"`
    Price   float64 `json:"price"`
}

type Order struct {
    ID     int         `json:"id"`
    Customer string    `json:"customer"`
    Items   []OrderItem `json:"items"`
}

func main() {
    order := Order{
        ID:       1001,
        Customer: "Alice",
        Items: []OrderItem{
            {"Laptop", 1, 999.99},
            {"Mouse", 2, 25.50},
        },
    }

    data, _ := json.MarshalIndent(order, "", "  ")
    fmt.Println("JSON:")
    fmt.Println(string(data))

    var restored Order
    json.Unmarshal(data, &restored)
    fmt.Printf("\nRestored: %+v\n", restored)
}

Summary