JSON Toolkit

JSON ke Go Struct: generator menyerahkan kerangka, empat hal butuh tangan anda

Intinya: Tempel contoh respons API ke konverter dan dalam sepuluh detik anda punya struct Go dengan tag — tetapi angka menjadi float64, field opsional tidak pernah menjadi pointer dengan sendirinya, omitempty tak bisa menanggalkan struct kosong, dan sebagian besar tanggal tetap string. Tabel pemetaan lengkap, keseimbangan antara pointer dan omitzero, serta checklist empat langkah untuk menuntaskan kode yang dihasilkan.

Menengah±6 menit bacaDiterbitkan 2026-11-22Diperbarui 2026-11-22
Mengonversi contoh JSON menjadi kode struct Go dengan alat online

Kesimpulan dulu: struct yang dihasilkan konverter dalam sepuluh detik bisa dikompilasi, tetapi belum siap produksi. Generator hanya mendeskripsikan satu-satunya sampel yang anda tempel — angka menjadi float64, field opsional tidak pernah menjadi pointer dengan sendirinya, omitempty tidak menanggalkan struct kosong, dan sebagian besar string tanggal tetap string. Empat celah ini setelah menempel tetap menjadi pekerjaan anda.

Mengubah respons API menjadi struct Go adalah pekerjaan murni mekanis, dan biaya kerja mekanis bersembunyi dalam diam: nama field salah ketik tidak memicu error kompilasi, hanya satu field yang selamanya bernilai nol; sakelar yang salah dalam penanganan null — dan "note": null muncul di produksi di tempat yang tak diharapkan siapa pun. Pembuatan struct menyelesaikan penyelarasan nama dan tipe, tetapi dua hal tak pernah sejajar sendiri: variasi di luar sampel anda dan jurang antara sistem tipe Go dan JSON.

Apa yang benar-benar dibaca generator: tabel pemetaan

Setiap konverter JSON → Go berjalan di atas tabel yang sama. Lewatkan respons pesanan tipikal melalui halaman /convert/go situs ini — tempel sampel, nyalakan tag json — dan anda dapat bentuk ini:

Nilai JSON Tipe Go dihasilkan Catatan
string string String tanggal biasanya tetap string, lihat time.Time di bawah
bilangan bulat float64 encoding/json mengurai angka secara internal sebagai double
desimal float64 Ganti field uang dengan pustaka decimal atau int64 dalam unit kecil
true / false bool Tanpa jebakan
null any Satu sampel null tidak membuktikan apa pun, fallback konservatif
objek struct bernama Objek bersarang menjadi struct tersendiri
objek kosong {} map[string]any Tak ada field yang teramati, generator tidak menebak
array []TipeElemen Tipe elemen disimpulkan dari sampel pertama
tipe campuran any Go tidak punya union, field multi-tipe jatuh ke any
// Sampel input
// {"id":"A-1029","items":[{"sku":"J-01","qty":2}],"coupon":null}
type Root struct {
  ID     string `json:"id"`
  Items  []Item `json:"items"`
  Coupon any    `json:"coupon"`
}

type Item struct {
  Sku string `json:"sku"`
  Qty int    `json:"qty"`
}

Tiga catatan. Objek bersarang items menjadi struct tersendiri Item yang dirujuk slice. coupon hanya muncul sebagai null: generator tak bisa membuktikan apa yang akan menjadi nanti dan jatuh ke any. Angka qty mendarat sebagai int atau float64 tergantung alat — strateginya berbeda, tetapi semua bertumpu pada asumsi yang sama: sampel adalah keseluruhan kebenaran.

Tag json: nama asli, opsi, dan tiga kesalahan mudah

Tag membawa kepadatan informasi tertinggi dalam output generator sekaligus bagian yang paling mudah salah saat menyunting. Aturannya datang langsung dari dokumentasi encoding/json:

Field int `json:"myName"`            // muncul di bawah kunci myName
Field int `json:"myName,omitempty"`  // field integer digugurkan saat kosong
Field int `json:",omitempty"`        // nama field bawaan, hanya opsinya
Field int `json:"-"`                 // selalu diabaikan, tak dikode maupun didekode
Field int64 `json:"id,string"`       // angka dikodekan di dalam string

Tiga kelalaian berbalas diingat. Pertama, koma pendahuluan di json:",omitempty" — saat anda hanya ingin melewati nilai kosong tanpa mengganti nama kunci, koma wajib ada; tanpanya, field dianggap sebagai kunci yang secara harfiah bernama ,omitempty. Kedua, pertahankan kunci JSON asli di tag (user_id, html_url) sementara field Go memakai konvensi idiomatik (UserID, HTMLURL): tanpa tag, pencocokan mengikuti nama field secara harfiah, sehingga kunci userId dalam respons tak pernah terpetakan — dengan diam. Ketiga, selain json:"-" ada json:"-," — yang kedua berarti kunci itu benar-benar bernama -.

Pointer: nil adalah satu-satunya cara membedakan "absen" dari "nol"

Sistem nilai nol Go tak mengizinkan int dan string menyatakan "field tak hadir" — 0 dan "" bisa jadi data nyata atau sekadar belum diurai. Kunci JSON yang sama punya tiga keadaan: hadir dengan nilai, hadir sebagai null, dan absen. Tipe by-value hanya menutupi yang pertama.

type Config struct {
  Note    string  `json:"note,omitempty"`   // digugurkan hanya saat tepat ""
  Alias   *string `json:"alias,omitempty"`  // digugurkan saat nil
  Details *Meta   `json:"details,omitempty"`
}

Nilai nol field pointer adalah nil. json.Unmarshal membiarkannya nil saat kunci tak ada atau null, dan omitempty melewatkannya hanya dalam kasus itu. Itulah sebabnya sebagian besar konverter menawarkan sakelar "gunakan pointer untuk objek bersarang": dinyalakan — struct bersarang menjadi *Item, dan dalam permintaan PATCH "field tak dikirim" dan "null dikirim untuk menghapus" akhirnya terpisah. Harganya pemeriksaan nil di mana-mana — p.Address.Street panic saat Address nil, salah satu crash runtime paling umum pada kode JSON di Go.

Struct kosong yang tak sanggup ditanggalkan omitempty, dan lubang yang diisi omitzero

Definisi resmi omitempty menilai berdasarkan nilai: false, 0, pointer nil, interface nil, dan array, slices, maps atau string berpanjang nol. Perhatikan yang tak ada dalam daftar: struct kosong.

type Order struct {
  Meta Meta `json:"meta,omitempty"`
}
type Meta struct {
  Version string
  Build   int
}

// Meta{Version: "1.0"} → "meta":{"version":"1.0","build":0}
// Meta{}              → "meta":{}   ← omitempty tak melakukan apa pun

Field bertipe struct tak pernah digugurkan oleh omitempty — ia hidup dalam memori sebagai wadah berukuran tetap, dan wadah yang ada bukanlah "kosong". Perbaikannya adalah mengubah field menjadi *Meta; hanya pointer nil yang dibuang. Sejak Go 1.24 ada sakelar kedua, omitzero: dinilai berdasarkan nilai nol Go, memanggil IsZero() bool saat tipe mendefinisikannya — satu-satunya cara menggugurkan time.Time nol. Dengan encoding/json/v2 (eksperimental di Go 1.25) semantik bergeser lagi: omitempty v2 menilai hasil JSON yang telah dikodekan (hanya null, "", {}, [] dihitung kosong), jadi count: 0 tetap ada di output; saat memigrasi kode lama, omitempty pada field bool dan numerik harus menjadi omitzero agar makna aslinya terjaga.

Setiap angka menjadi float64: jebakan bilangan bulat besar

Tanpa tipe eksplisit, decoder encoding/json menganggap angka sebagai float64, dan float64 hanya punya 53 bit mantissa. Kasus klasik JavaScript — 9007199254740993 menjadi 9007199254740992 — juga ada di Go, selama field tujuan adalah float64 atau any.

var v map[string]any
_ = json.Unmarshal([]byte(`{"id":9007199254740993}`), &v)
// v["id"] adalah float64(9007199254740992), presisi sudah hilang

Tiga jalan keluar. Deklarasikan field struct sebagai int64 dan decoder mengurai persis ke sana. Saat perlu melewati any, panggil decoder.UseNumber() agar angka mendarat sebagai string json.Number yang anda konversi secara sadar. Jangan pernah pakai floating-point untuk uang — simpan unit kecil dalam int64 atau gunakan pustaka decimal. Setiap kali API mengembalikan ID snowflake atau nomor pesanan 64 bit, bagian ini adalah pemeriksaan wajib.

time.Time hanya menerima RFC 3339

Di depan "2024-01-15T10:30:00Z" generator memetakan time.Time; di depan "2024-01-15 10:30:00" meninggalkan string. Bukan malas — itu batasan keras encoding/json: time.Time mengimplementasikan UnmarshalJSON dan mengurai secara ketat dengan layout RFC 3339 2006-01-02T15:04:05Z07:00. T hilang, zona waktu hilang, atau Z diikuti offset — semuanya gagal:

parsing time "\"2022-07-27T14:16:00Z04:00\"" as
"\"2006-01-02T15:04:05Z07:00\"": cannot parse "04:00\"" as "\""

Ketika format upstream tak bisa diubah, perbaikan standar adalah tipe kustom yang membungkus time.Time dengan UnmarshalJSON yang mencoba beberapa layout:

type CustomDate struct{ time.Time }

func (c *CustomDate) UnmarshalJSON(b []byte) error {
  s := strings.Trim(string(b), `"`)
  t, err := time.Parse("2006-01-02 15:04:05", s)
  if err != nil {
    t, err = time.Parse(time.RFC3339, s)
    if err != nil {
      return fmt.Errorf("invalid date format: %w", err)
    }
  }
  c.Time = t
  return nil
}

Checklist empat langkah setelah menghasilkan

Empat langkah memisahkan output generator dari kode produksi, dan melewatinya sekali lebih murah daripada debugging kemudian:

  1. Ganti setiap fallback any: cari any, periksa tiga hingga lima sampel nyata untuk setiap field yang jatuh ke fallback lalu mendaratkan pada tipe konkret atau pointer;
  2. Periksa ulang lebar numerik: pindahkan ID, jumlah uang, dan penghitung dari float64 ke int64 / int32 / decimal; bila ragu tentang lebar, tulis int64;
  3. Tandai opsionalitas: pointer atau omitempty/omitzero untuk field objek dalam array, body PATCH, dan field nullable API pihak ketiga — putuskan semantik nil sekali, di sini;
  4. Kompilasi dan uji bolak-balik: jalankan go vet, lalu tambahkan uji bolak-balik Marshal→Unmarshal untuk mengunci format di jalur — itu menangkap pergeseran perilaku pembaruan encoding/json di masa depan.

Dari sampel ke kontrak: batas konverter

Konverter menjawab "bagaimana tampaknya sampel ini", bukan "bagaimana antarmuka ini akan selalu tampak". Alat pesaing mengatakannya jujur dalam dokumentasi mereka sendiri: satu sampel tak dapat membuktikan variasi produksi — opsionalitas, format tanggal, dan nilai enum butuh tinjauan manusia. Jadi bangun kebiasaan: sebelum menempel, kumpulkan respons yang paling berpotensi memperlihatkan perbedaan (daftar kosong, semua field terisi, satu berisi null); setelah menghasilkan, perlakukan output sebagai draf, bukan serahan. Jika antarmuka punya dokumen kontrak, buat batasannya eksplisit dengan JSON Schema dan selaraskan kode yang dihasilkan dengannya — mengalahkan inferensi dari sampel berlipat ganda. Untuk pandangan lintas bahasa atas masalah yang sama, sisi Java dibahas dalam uji lapangan generator Java kami, kontrak frontend dalam interface TypeScript; jurang presisi numerik kembali di setiap bahasa dengan kostum berbeda, dirinci dalam jebakan angka besar JSON.

Field apa saja yang setelah dihasilkan masih butuh suntingan manual?

Setidaknya empat: fallback any, lebar numerik (float64 → int64), mengubah field opsional menjadi pointer, dan apakah field tanggal sebaiknya string atau time.Time. Keempatnya adalah variasi produksi yang tak terlihat dalam sampel; generator tak menebak, manusia harus melengkapi.

Mengapa field saya masih muncul di JSON setelah menambah omitempty?

omitempty hanya melewati nilai nol: false, 0, "", nil, slices kosong. Struct kosong {} bukan nilai nol, jadi ia bertahan — ubah field menjadi pointer. time.Time nol butuh omitzero, bukan omitempty.

Mengapa ID bilangan bulat besar saya berubah setelah deserialisasi?

Tanpa tipe eksplisit, encoding/json mengurai angka sebagai float64 yang membawa 53 bit mantissa; bilangan bulat melebihi 2^53 kehilangan presisi. Tiplah field sebagai int64, atau panggil UseNumber() untuk menyimpan angka sebagai json.Number.

Kapan field objek bersarang sebaiknya menjadi pointer?

Dua kasus: field bisa absen atau null (nil memisahkan "tak dikirim" dari "nilai nol"), dan permintaan PATCH perlu membedakan "tak dikirim" dengan "null dikirim untuk menghapus". Pada struct respons biasa dengan field non-nullable, tipe by-value lebih aman — bayar biaya pemeriksaan nil hanya saat pembedaan benar-benar dibutuhkan.