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.
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
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)
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"}
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)
}
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))
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))
}
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
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"])
}
}
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)
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)
}
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)
}
json.Marshal / json.Unmarshal para mag-convert between Go ug JSONjson:"name,omitempty") nagcontrol sa serializationmap[string]any kung wa kay sure sa JSON structureencoding/gob para Go-to-Go binary encoding (exclusive na)