Bagaimana cara mengenkod/mendekod JSON di Go?

Question

Accepted Answer

Paket **`encoding/json`** dalam pustaka standard Go menangani serialisasi JSON (marshaling) dan deserialisasi (unmarshaling), memetakan antara struct Go dan JSON. **Struct tags** mengontrol penamaan field, dan ini adalah tulang punggung dari sebagian besar API web Go.

## Marshaling: struct Go → JSON

```go
type User struct {
    Name    string `json:"name"`              // tag maps the field to a JSON key
    Email   string `json:"email"`
    Age     int    `json:"age,omitempty"`     // omitempty → skip if zero/empty
    private string                             // unexported → NOT serialized (lowercase)
}

u := User{Name: "Ann", Email: "ann@x.com", Age: 30}
data, err := json.Marshal(u)
fmt.Println(string(data))   // {"name":"Ann","email":"ann@x.com","age":30}
```

`json.Marshal` mengubah struct menjadi byte JSON. **Hanya field yang diekspor (dimulai dengan huruf besar) yang diserialisasi** — field yang tidak diekspor dilewati.

## Peran struct tags

```go
type Product struct {
    ID    int    `json:"id"`                  // → "id"
    Name  string `json:"product_name"`        // → "product_name" (rename)
    Price float64 `json:"price,omitempty"`     // omit if 0
    Notes string `json:"-"`                    // "-" → NEVER serialize this field
}
```

Tanpa tag, kunci JSON diatur ke nama field yang tepat (dimulai dengan huruf besar). Tag memungkinkan Anda mengontrol nama kunci JSON, menghilangkan nilai kosong (`omitempty`), dan mengecualikan field sama sekali (`-`) — penting untuk mencocokkan konvensi API (misalnya snake_case JSON).

## Unmarshaling: JSON → struct Go

```go
jsonData := []byte(`{"name":"Bob","email":"bob@x.com","age":25}`)

var user User
err := json.Unmarshal(jsonData, &user)   // pass a POINTER to populate it
if err != nil { log.Fatal(err) }
fmt.Println(user.Name)   // "Bob"
```

`json.Unmarshal` mengurai JSON ke dalam struct — Anda harus mengirimkan **pointer** sehingga dapat mengisi struct. Field dicocokkan berdasarkan tag/nama (tidak peka huruf besar/kecil).

## Bekerja dengan JSON yang tidak dikenal/dinamis

```go
// when the structure is unknown, unmarshal into a map or interface{}
var result map[string]interface{}
json.Unmarshal(data, &result)
name := result["name"].(string)        // type-assert the value (JSON numbers → float64!)
```

## Streaming dengan Encoder/Decoder (untuk I/O)

```go
// encode directly to an io.Writer (e.g. an HTTP response) — efficient, no intermediate buffer
json.NewEncoder(w).Encode(user)

// decode directly from an io.Reader (e.g. an HTTP request body)
json.NewDecoder(r.Body).Decode(&user)
```

Untuk server web, `Encoder`/`Decoder` bekerja langsung dengan stream (badan permintaan/respons) — pola umum dalam handler.

## Mengapa ini penting

Pengenkod/pendekod JSON adalah fundamental untuk praktis semua pengembangan web Go — REST API, microservices, dan konfigurasi semuanya bergantung pada konversi antara struct Go dan JSON.

Paket `encoding/json` (pustaka standard, tidak ada ketergantungan) adalah alat standar, dan memahaminya dengan baik adalah pengetahuan harian yang penting: cara marshaling/unmarshaling bekerja, aturan penting bahwa **hanya field yang diekspor yang diserialisasi**, dan khususnya **struct tags** (mengontrol nama kunci JSON dengan `json:"..."`, `omitempty` untuk melewati nilai kosong, `-` untuk mengecualikan) yang diperlukan untuk mencocokkan konvensi API nyata seperti snake_case.

Mengetahui cara mengirimkan pointer ke `Unmarshal`, menangani JSON dinamis melalui peta/`interface{}` (dengan gotcha bahwa angka JSON didekod menjadi `float64`), dan menggunakan streaming `Encoder`/`Decoder` untuk badan HTTP mencakup kebutuhan praktis membangun API.

Ini adalah bagian yang konstan dan praktis dari pekerjaan backend Go.