Struct, method & receiver

Struct adalah kumpulan field; method adalah fungsi yang menempel pada tipe. Tidak ada pewarisan, tidak ada konstruktor bawaan — dan pilihan receiver menentukan apakah perubahanmu tersimpan.

Struct dan konstruktornya

type Pesanan struct {
	ID        int64
	Pelanggan string
	Item      []Item
	Total     Rupiah
	Dibuat    time.Time
}

// Tidak ada kata kunci "constructor". Konvensinya fungsi New yang
// mengembalikan pointer, dan yang mengisi field yang tidak boleh kosong.
func NewPesanan(pelanggan string) *Pesanan {
	return &Pesanan{
		Pelanggan: pelanggan,
		Item:      make([]Item, 0, 4),
		Dibuat:    time.Now(),
	}
}

p := NewPesanan("Ani")
p2 := Pesanan{Pelanggan: "Budi"}   // literal — sah, tapi Item-nya nil
var p3 Pesanan                      // nilai nol — semua field bernilai nol

Receiver: nilai atau pointer

// Receiver NILAI — menerima salinan. Perubahan tidak tersimpan.
func (p Pesanan) Ringkasan() string {
	return fmt.Sprintf("#%d %s", p.ID, p.Pelanggan)
}

// Receiver POINTER — menerima alamat. Perubahan tersimpan.
func (p *Pesanan) Tambah(i Item) {
	p.Item = append(p.Item, i)
	p.Total += i.Harga
}

p := NewPesanan("Ani")
p.Tambah(Item{Harga: 25000})   // Go otomatis mengambil alamatnya: (&p).Tambah(...)

Jebakan receiver nilai yang mengubah slice

// SALAH — terlihat bekerja, tapi tidak
func (p Pesanan) TambahSalah(i Item) {
	p.Item = append(p.Item, i)   // p adalah salinan; hilang saat fungsi selesai
}

// Lebih licik: slice-nya SAMA, jadi mengubah ELEMEN justru terlihat
func (p Pesanan) UbahHarga(idx int, h Rupiah) {
	p.Item[idx].Harga = h   // ← ini BERPENGARUH ke pemanggil
}

Salinan struct menyalin header slice, bukan datanya. Jadi append hilang tapi perubahan elemen tersimpan. Perilaku setengah-setengah inilah alasan aturan "jangan campur" tadi.

Embedding: komposisi, bukan pewarisan

type Model struct {
	ID       int64
	Dibuat   time.Time
	Diubah   time.Time
}

func (m *Model) Sentuh() { m.Diubah = time.Now() }

type Produk struct {
	Model            // ← embedded: tanpa nama field
	Nama  string
	Harga Rupiah
}

p := Produk{}
p.ID = 7        // dipromosikan dari Model
p.Sentuh()      // method Model ikut dipromosikan
p.Model.ID = 7  // bentuk panjangnya, selalu tersedia

Method pada tipe apa pun

// Tipe bernama di atas int64 — bukan alias, tipe yang berbeda.
type Rupiah int64

func (r Rupiah) String() string {
	return fmt.Sprintf("Rp%s", tandaRibuan(int64(r)))
}

type IDPengguna int64
type IDProduk int64

// Compiler menolak menukar keduanya — bug yang di banyak bahasa
// baru ketahuan di produksi.
func Ambil(u IDPengguna) { }
Ambil(IDProduk(7))   // gagal kompilasi

Tipe bernama di atas tipe primitif adalah salah satu alat paling murah untuk mencegah kesalahan di aplikasi besar. Uang, ID, satuan waktu, dan kode negara semua layak punya tipe sendiri — biayanya satu baris, dan compiler yang menegakkannya selamanya.

Field yang tidak diekspor menjaga invarian

type Saldo struct {
	nilai Rupiah   // huruf kecil: tidak terlihat dari paket lain
}

func (s *Saldo) Tarik(n Rupiah) error {
	if n <= 0 {
		return errors.New("jumlah harus positif")
	}
	if n > s.nilai {
		return ErrSaldoKurang
	}
	s.nilai -= n
	return nil
}

Karena nilai huruf kecil, tidak ada kode di luar paket ini yang bisa membuat saldo negatif. Ini padanan Go untuk enkapsulasi: batasnya paket, bukan tipe. Di dalam satu paket, semua kode bisa saling menyentuh field privat — dan itu disengaja, karena paket adalah unit desain di Go.

Ringkasan keputusan