encoding/json & struct tag

Di Go, kontrak JSON API ditulis sebagai tag di sebelah field struct. Materi ini tentang aturan yang berlaku, dan tentang memisahkan struct DTO dari struct domain sebelum keduanya terlanjur menyatu.

Tag menentukan bentuk keluaran

type Produk struct {
	ID        int64     `json:"id"`
	Nama      string    `json:"nama"`
	Harga     int64     `json:"harga"`
	Deskripsi string    `json:"deskripsi,omitempty"`  // hilang kalau ""
	Rahasia   string    `json:"-"`                    // TIDAK PERNAH ikut
	Dibuat    time.Time `json:"dibuat"`               // RFC 3339 otomatis
	internal  string                                   // huruf kecil: tidak ikut
}

Tiga perilaku default yang mengejutkan

1. []byte menjadi base64. Bukan array angka. Ini sering mengejutkan saat menyandingkan API Go dengan API bahasa lain.
2. Slice nil menjadi null, bukan []. Klien yang langsung melakukan .map() akan gagal. Perbaikannya: inisialisasi dengan make([]T, 0) sebelum encode.
3. Angka masuk ke any sebagai float64. ID 64-bit besar kehilangan presisi. Pakai struct bertipe, atau json.Number.

// Slice kosong yang benar-benar mengeluarkan []
type Daftar struct {
	Item []Produk `json:"item"`
}

d := Daftar{Item: []Produk{}}   // -> {"item":[]}
d := Daftar{}                    // -> {"item":null}

Decode: apa yang terjadi pada field asing

// Diam-diam mengabaikan field yang tidak dikenal — default.
var p Produk
if err := json.Unmarshal(body, &p); err != nil { ... }

// Untuk API internal: tolak field asing supaya salah ketik ketahuan.
dec := json.NewDecoder(r.Body)
dec.DisallowUnknownFields()
if err := dec.Decode(&p); err != nil {
	return fmt.Errorf("body tidak valid: %w", err)
}

Risiko keamanan: jangan decode ke struct domain

// ❌ BAHAYA — pengguna bisa mengirim {"peran":"admin","saldo":999999999}
var u User
json.NewDecoder(r.Body).Decode(&u)
db.Simpan(ctx, u)

Ini mass assignment dalam bentuk Go. Struct domainmu punya field yang tidak boleh datang dari input pengguna — peran, saldo, status verifikasi, ID pemilik. Kalau decoder diarahkan langsung ke sana, semuanya bisa diisi siapa pun.

// ✅ DTO terpisah: hanya berisi apa yang boleh dikirim pengguna
type buatUserReq struct {
	Nama  string `json:"nama"`
	Email string `json:"email"`
}

func (h *Handler) BuatUser(w http.ResponseWriter, r *http.Request) {
	var req buatUserReq
	dec := json.NewDecoder(http.MaxBytesReader(w, r.Body, 1<<20)) // batasi 1 MB
	dec.DisallowUnknownFields()
	if err := dec.Decode(&req); err != nil {
		tulisError(w, r, &ErrValidasi{Field: "body", Pesan: "JSON tidak valid"})
		return
	}

	// Field sensitif diisi server, bukan dari body.
	u := domain.User{Nama: req.Nama, Email: req.Email, Peran: domain.PeranBiasa}
	...
}

Struct terpisah untuk masuk dan keluar

Ongkosnya beberapa baris konversi per endpoint. Yang dibeli: menambah kolom database tidak diam-diam mengubah API publik, dan menghapus field dari API tidak memaksa mengubah domain. Untuk aplikasi yang hidup bertahun-tahun, pemisahan ini terbayar sangat cepat.

Kontrol penuh dengan Marshaler

type Rupiah int64

func (r Rupiah) MarshalJSON() ([]byte, error) {
	return json.Marshal(struct {
		Jumlah int64  `json:"jumlah"`
		Format string `json:"format"`
	}{int64(r), fmt.Sprintf("Rp%d", int64(r))})
}