Category: Tutorial

Di Belajar Golang dari Nol #8 kita sudah merapikan kode ke dalam package dan module. Struktur project kamu sekarang sudah bersih. Tapi ada satu masalah yang belum kita sentuh: bagaimana kalau satu tugas bisa dikerjakan dengan banyak cara berbeda? Di sinilah interface masuk. Ini salah satu fitur paling penting di Go, dan kabar baiknya, konsepnya sederhana.

Masalah: satu tugas, banyak cara

Bayangkan kamu membangun aplikasi toko online. Setiap kali ada pesanan baru, sistem harus mengirim notifikasi ke pembeli. Ada yang mau lewat WhatsApp, ada yang lewat email, ada yang lewat SMS.

Dengan bekal sampai bagian 8, kamu mungkin akan menulis begini:

func KirimNotifikasi(via string, pesan string) error {
	if via == "wa" {
		// logika kirim WhatsApp
	} else if via == "email" {
		// logika kirim email
	} else if via == "sms" {
		// logika kirim SMS
	}
	return nil
}

Kode ini jalan. Tapi coba pikirkan nasibnya tiga bulan lagi. Perusahaan mau tambah notifikasi lewat Telegram. Kamu harus buka function ini lagi, tambah satu cabang else if lagi. Tambah push notification, tambah cabang lagi. Function-nya makin gemuk, dan setiap perubahan berisiko merusak cabang yang sudah jalan.

Masalah sebenarnya bukan di if else. Masalahnya, function ini harus tahu detail semua cara pengiriman. Padahal yang dia butuhkan cuma satu hal: sesuatu yang bisa mengirim pesan. Titik.

Interface itu kontrak

Interface di Go adalah cara kita menulis kebutuhan itu secara eksplisit. Bentuknya begini:

type Notifier interface {
	Kirim(pesan string) error
}

Baca deklarasi ini seperti kontrak kerja. Perusahaan pasang lowongan: “kami butuh kurir, syaratnya bisa mengantar paket”. Perusahaan tidak peduli kurirnya naik motor, mobil, atau sepeda. Selama bisa mengantar paket, kontrak terpenuhi, dia bisa dipekerjakan.

Notifier adalah kontrak versi kode. Isinya satu syarat: siapa pun yang mau disebut Notifier harus punya method Kirim yang menerima string dan mengembalikan error. Interface tidak berisi implementasi sama sekali. Dia cuma daftar syarat.

Implementasi implisit, ciri khas Go

Di bahasa lain seperti Java atau PHP, kamu harus menulis implements Notifier secara eksplisit di deklarasi class. Go tidak begitu. Di Go, sebuah type otomatis memenuhi interface kalau dia punya semua method yang disyaratkan. Tidak ada kata kunci implements. Tidak ada pendaftaran apa pun.

Kembali ke analogi kontrak kerja: kamu tidak perlu sertifikat bertuliskan “saya kurir”. Kalau kamu terbukti bisa mengantar paket, kamu memenuhi syarat. Kemampuanmu yang bicara, bukan labelmu.

Kenapa ini enak? Dua alasan:

• Kamu bisa membuat interface untuk type yang bukan milikmu. Misalnya type dari library orang lain sudah punya method yang cocok, dia otomatis memenuhi interface buatanmu tanpa mengubah kode library itu.
• Kode implementasi tidak perlu tahu interface apa saja yang dia penuhi. Struct WhatsAppSender cukup fokus mengirim WhatsApp. Urusan dia dipakai sebagai Notifier atau bukan, itu urusan pemakainya.

Contoh utuh: sistem notifikasi

Sekarang kita rakit semuanya. Dua struct, satu interface, satu function yang menerima interface:

package main

import (
	"errors"
	"fmt"
)

type Notifier interface {
	Kirim(pesan string) error
}

type WhatsAppSender struct {
	Nomor string
}

func (w WhatsAppSender) Kirim(pesan string) error {
	if w.Nomor == "" {
		return errors.New("nomor WhatsApp kosong")
	}
	fmt.Println("[WA ke", w.Nomor+"]", pesan)
	return nil
}

type EmailSender struct {
	Alamat string
}

func (e EmailSender) Kirim(pesan string) error {
	if e.Alamat == "" {
		return errors.New("alamat email kosong")
	}
	fmt.Println("[Email ke", e.Alamat+"]", pesan)
	return nil
}

func ProsesNotifikasi(n Notifier, pesan string) {
	err := n.Kirim(pesan)
	if err != nil {
		fmt.Println("Gagal kirim:", err)
	}
}

func main() {
	wa := WhatsAppSender{Nomor: "0812xxxx1234"}
	email := EmailSender{Alamat: "budi@tokokopi.id"}

	ProsesNotifikasi(wa, "Pesanan kamu sudah dikirim")
	ProsesNotifikasi(email, "Pesanan kamu sudah dikirim")
}

Perhatikan ProsesNotifikasi. Parameternya bertipe Notifier, bukan WhatsAppSender atau EmailSender. Function ini tidak tahu dan tidak peduli pesan dikirim lewat apa. Dia cuma pegang kontrak: apa pun yang masuk, pasti bisa dipanggil method Kirim-nya.

Output program di atas:

[WA ke 0812xxxx1234] Pesanan kamu sudah dikirim
[Email ke budi@tokokopi.id] Pesanan kamu sudah dikirim

Karena Notifier adalah type biasa, kamu juga bisa membuat slice berisi campuran implementasi. Ini pola broadcast yang sering dipakai:

	daftar := []Notifier{
		WhatsAppSender{Nomor: "0812xxxx1234"},
		EmailSender{Alamat: "budi@tokokopi.id"},
		EmailSender{},
	}

	for _, n := range daftar {
		ProsesNotifikasi(n, "Promo akhir bulan dimulai")
	}

Elemen ketiga sengaja dibuat kosong supaya kelihatan jalur error-nya:

[WA ke 0812xxxx1234] Promo akhir bulan dimulai
[Email ke budi@tokokopi.id] Promo akhir bulan dimulai
Gagal kirim: alamat email kosong

Sekarang bandingkan dengan versi if else di awal. Mau tambah Telegram? Buat struct TelegramSender dengan method Kirim, selesai. ProsesNotifikasi tidak disentuh sama sekali. Kode lama tetap aman, fitur baru tinggal ditambahkan. Ini yang dimaksud kode fleksibel.

Interface kecil itu idiomatik

Perhatikan Notifier cuma punya satu method. Ini bukan kebetulan. Di Go, interface yang bagus justru yang kecil. Makin sedikit syarat di kontrak, makin banyak type yang bisa memenuhinya, makin fleksibel kodemu.

Standard library Go penuh contoh interface satu method. Dua yang paling sering kamu temui:

error ternyata interface

Masih ingat bagian 3 waktu kita belajar error handling? Waktu itu saya bilang error akan kita bahas lebih dalam nanti. Ini dia bayarannya. error yang selama ini kamu pakai sebenarnya interface bawaan:

type error interface {
	Error() string
}

Artinya, type apa pun yang punya method Error() string bisa dipakai sebagai error. Itulah kenapa kamu bisa mengembalikan hasil errors.New, hasil fmt.Errorf, atau error buatan library mana pun dari function yang sama. Semuanya cuma memenuhi satu kontrak kecil.

fmt.Stringer

Interface kecil lain yang berguna adalah fmt.Stringer, kontraknya satu method String() string. Kalau struct kamu memenuhinya, fmt.Println otomatis memakai method itu saat mencetak:

package main

import "fmt"

type Produk struct {
	Nama  string
	Harga int
}

func (p Produk) String() string {
	return fmt.Sprintf("%s (Rp%d)", p.Nama, p.Harga)
}

func main() {
	p := Produk{Nama: "Kopi Gayo 250g", Harga: 85000}
	fmt.Println(p)
}

Tanpa method String, outputnya format default: {Kopi Gayo 250g 85000}. Dengan method itu, outputnya jadi Kopi Gayo 250g (Rp85000). Kamu tidak pernah mendaftarkan apa pun ke package fmt. Dia cuma mengecek: type ini memenuhi kontrak Stringer atau tidak. Implementasi implisit bekerja diam-diam di sini.

any, interface kosong, dan type assertion

Ada satu interface ekstrem: interface tanpa syarat sama sekali, ditulis interface{} atau alias modernnya, any. Karena kontraknya kosong, semua type otomatis memenuhinya. Variabel bertipe any bisa diisi apa saja.

Kedengarannya praktis, tapi hati-hati. Begitu data masuk ke any, compiler tidak bisa lagi menjaga kamu. Kamu kehilangan informasi type, dan itu mahal. Untuk mengambil kembali type aslinya, kamu butuh type assertion:

var data any = "halo"

s, ok := data.(string)
if ok {
	fmt.Println("panjang teks:", len(s))
} else {
	fmt.Println("data bukan string")
}

Bentuk data.(string) artinya “saya yakin isi data adalah string, tolong keluarkan”. Variabel ok bernilai true kalau tebakanmu benar. Selalu pakai bentuk dua nilai ini. Bentuk satu nilai tanpa ok akan membuat program panic kalau tebakannya salah.

Aturan praktisnya: pakai any hanya kalau memang tidak ada pilihan, misalnya saat menangani JSON yang strukturnya tidak tentu. Untuk kode sehari-hari, interface dengan kontrak jelas seperti Notifier hampir selalu lebih baik.

Kapan tidak perlu interface

Setelah paham interface, ada godaan untuk membuatnya di mana-mana. Tahan dulu. Interface itu abstraksi, dan abstraksi ada biayanya: kode jadi lebih sulit dilacak karena pembaca harus mencari implementasi aslinya.

Patokan sederhananya:

• Kalau cuma ada satu implementasi dan belum ada rencana nyata menambah yang lain, pakai struct langsung. Jangan bikin UserServiceInterface hanya karena terlihat rapi.
• Buat interface saat kebutuhannya muncul: ada implementasi kedua, atau kamu perlu memisahkan kode dari dependensi eksternal.
• Definisikan interface di sisi pemakai, bukan di sisi implementasi. Ini kebiasaan idiomatik di Go, beda dengan kebiasaan di Java.

Ingat prinsipnya: interface menjawab masalah “banyak cara untuk satu tugas”. Kalau caranya memang cuma satu, tidak ada masalah yang perlu dijawab.

Latihan: sistem pembayaran mini

Sekarang giliran kamu. Kita buat sistem checkout yang menerima beberapa metode pembayaran. Kontraknya satu: bisa membayar sejumlah uang. Aturan validasinya beda per metode. Transfer bank punya minimal nominal, e-wallet dibatasi saldo.

package main

import (
	"errors"
	"fmt"
)

type MetodePembayaran interface {
	Bayar(jumlah float64) error
}

type TransferBank struct {
	NamaBank   string
	NoRekening string
}

func (t TransferBank) Bayar(jumlah float64) error {
	if t.NoRekening == "" {
		return errors.New("nomor rekening belum diisi")
	}
	if jumlah < 10000 {
		return errors.New("minimal transfer bank Rp10.000")
	}
	fmt.Printf("Transfer Rp%.0f via %s berhasil\n", jumlah, t.NamaBank)
	return nil
}

type EWallet struct {
	Provider string
	Saldo    float64
}

func (e EWallet) Bayar(jumlah float64) error {
	if jumlah > e.Saldo {
		return errors.New("saldo " + e.Provider + " tidak cukup")
	}
	fmt.Printf("Bayar Rp%.0f pakai %s berhasil\n", jumlah, e.Provider)
	return nil
}

func Checkout(m MetodePembayaran, total float64) {
	fmt.Printf("Memproses pembayaran Rp%.0f...\n", total)
	err := m.Bayar(total)
	if err != nil {
		fmt.Println("Pembayaran gagal:", err)
		return
	}
	fmt.Println("Pesanan dikonfirmasi")
}

func main() {
	bca := TransferBank{NamaBank: "BCA", NoRekening: "1234567890"}
	dana := EWallet{Provider: "Dana", Saldo: 50000}

	Checkout(bca, 150000)
	Checkout(dana, 35000)
	Checkout(dana, 100000)
	Checkout(TransferBank{NamaBank: "BRI"}, 150000)
}

Jalankan dengan go run main.go. Outputnya:

Memproses pembayaran Rp150000...
Transfer Rp150000 via BCA berhasil
Pesanan dikonfirmasi
Memproses pembayaran Rp35000...
Bayar Rp35000 pakai Dana berhasil
Pesanan dikonfirmasi
Memproses pembayaran Rp100000...
Pembayaran gagal: saldo Dana tidak cukup
Memproses pembayaran Rp150000...
Pembayaran gagal: nomor rekening belum diisi

Amati dua hal. Pertama, Checkout memperlakukan semua metode sama rata lewat kontrak MetodePembayaran, padahal aturan validasi di baliknya berbeda. Kedua, dua kasus gagal ditangani rapi tanpa satu pun if else soal jenis metode di dalam Checkout.

Untuk latihan mandiri, coba tambah KartuKredit dengan validasi limit, lalu masukkan ke pemanggilan Checkout. Kalau kamu tidak perlu mengubah function Checkout sama sekali, berarti kamu sudah paham inti bab ini.

Rangkuman dan bagian selanjutnya

Hari ini kamu belajar bahwa interface adalah kontrak: daftar method yang harus dipenuhi, tanpa implementasi. Go memakai implementasi implisit, jadi type cukup punya method yang cocok. Interface kecil seperti error dan fmt.Stringer adalah gaya idiomatik Go. any ada untuk kasus khusus, dan type assertion adalah pintu keluarnya. Terakhir, jangan bikin interface untuk satu implementasi tanpa alasan.

Di bagian 10 kita masuk ke materi yang membuat Go terkenal: “Goroutine dan Channel: Kenalan dengan Concurrency”. Sampai ketemu di sana.

Kalau bisnismu butuh aplikasi yang dibangun dengan fondasi rapi seperti ini, tim Arrazy menyediakan jasa pengembangan sistem aplikasi dari perancangan sampai perawatan.

Di Belajar Golang dari Nol #7 kita sudah membereskan pointer. Materi paling menakutkan di seri ini sudah lewat. Sekarang saatnya bicara soal kerapian. Selama tujuh bagian, semua latihan kita tulis di satu file bernama main.go. Untuk belajar, itu wajar. Untuk proyek sungguhan, itu resep pusing. Di bagian ini kita belajar memecah kode ke banyak file dan banyak folder. Kuncinya dua hal: package dan Go module.

Masalahnya: main.go yang mulai gemuk

Coba lihat file latihan Anda dari bagian 4 sampai 7. Isinya kira-kira begini. Ada struct Produk. Ada beberapa method. Ada function pembantu untuk format harga. Ada function main. Semua tumpuk di satu file.

// main.go, semua campur di sini
package main

import "fmt"

type Produk struct { ... }

func (p *Produk) TambahStok(jumlah int) { ... }
func (p *Produk) KurangiStok(jumlah int) error { ... }

func formatRupiah(angka int) string { ... }
func cetakLaporan(daftar []Produk) { ... }

func main() { ... }

Untuk 100 baris, ini masih aman. Tapi bayangkan aplikasi kasir sederhana. Ada produk, pelanggan, transaksi, dan laporan. Kalau semua ditulis di main.go, file itu bisa tembus ribuan baris. Anda akan scroll ke sana kemari cuma untuk cari satu function. Nama function juga mulai bentrok. Simpan() untuk produk atau untuk pelanggan? Terpaksa dinamai SimpanProduk dan SimpanPelanggan, lalu file makin ramai.

Bahasa lain menyelesaikan ini dengan class dan namespace. Go menyelesaikannya dengan package. Satu package berisi kode yang topiknya sama. Kode soal produk masuk package produk. Alur utama program tetap di package main.

Go module: KTP proyek Anda

Sebelum bikin package, kita lunasi dulu satu utang dari bagian 1. Waktu itu saya minta Anda menjalankan go mod init tanpa penjelasan panjang. Sekarang waktunya dijelaskan tuntas.

Module adalah unit proyek di Go. Satu module berisi satu proyek utuh: semua file, semua folder, semua package di dalamnya. Module juga mencatat proyek Anda bergantung ke library apa saja. Anggap saja module itu KTP proyek. Dia menyimpan nama proyek dan daftar kenalannya.

Membuatnya cukup satu perintah di folder proyek.

go mod init github.com/budi/tokokita

Perintah ini menghasilkan file go.mod. Isinya pendek.

module github.com/budi/tokokita

go 1.22

Baris pertama adalah nama module. Baris kedua adalah versi Go minimum yang dipakai proyek ini. Sudah, itu saja untuk sekarang.

Soal penamaan, ada kebiasaan yang hampir semua programmer Go ikuti: nama module memakai path repository tempat kode itu nanti disimpan. Kalau username GitHub Anda budi dan proyeknya bernama tokokita, nama module-nya github.com/budi/tokokita. Kenapa begitu? Karena kalau suatu hari orang lain mau memakai kode Anda, Go bisa langsung tahu harus download dari mana. Nama module sekaligus jadi alamatnya. Untuk latihan lokal, Anda bebas menamai apa saja, misalnya tokokita saja. Tapi biasakan format path repo sejak awal supaya tidak perlu ganti nanti.

Membuat package sendiri

Sekarang kita pecah proyeknya. Aturannya sederhana: satu folder berisi satu package. Semua file di folder yang sama harus memakai nama package yang sama. Kita buat folder produk di dalam proyek, lalu isi dengan file produk.go.

tokokita/
├── go.mod
├── main.go
└── produk/
    └── produk.go

Baris pertama di produk/produk.go bukan lagi package main, tapi package produk. Nama package sebaiknya sama dengan nama foldernya. Go tidak memaksa, tapi kalau berbeda, orang yang baca kode Anda akan bingung.

Satu hal penting: hanya package main yang punya function main() dan bisa dijalankan langsung. Package lain sifatnya seperti kotak perkakas. Isinya dipakai oleh package lain, tidak jalan sendiri.

Huruf besar dan huruf kecil: aturan akses Go

Di banyak bahasa, ada kata kunci public dan private untuk mengatur apa yang boleh diakses dari luar. Go tidak punya kata kunci itu. Aturannya lebih sederhana dan agak unik: dilihat dari huruf pertama namanya.

• Nama diawali huruf besar, misalnya Produk atau TambahStok: exported. Bisa diakses dari package lain.
• Nama diawali huruf kecil, misalnya hitungDiskon: unexported. Hanya bisa dipakai di dalam package itu sendiri. Privat.

Aturan ini berlaku untuk semuanya: function, struct, method, field struct, sampai variabel level package. Field struct yang huruf kecil pun tidak bisa dibaca dari luar package-nya.

Masih ingat di bagian 1 saya bilang penulisan fmt.Println dengan P besar itu bukan selera, tapi keharusan? Ini jawabannya. Println ada di package fmt milik tim Go. Supaya bisa kita panggil dari luar, dia harus exported. Makanya hurufnya besar. Kalau tim Go menamainya println, kita tidak akan bisa memakainya sama sekali.

Meng-import package sendiri

Lalu bagaimana main.go memakai package produk? Lewat import, sama seperti kita meng-import fmt selama ini. Bedanya, path-nya adalah nama module ditambah nama folder.

import "github.com/budi/tokokita/produk"

Go membaca path itu begini: cari module github.com/budi/tokokita. Itu proyek kita sendiri, sesuai go.mod. Lalu masuk ke folder produk. Setelah di-import, semua isi yang exported bisa dipanggil dengan awalan nama package-nya: produk.Baru(...), mirip fmt.Println(...).

Praktik: memecah sistem stok jadi dua file

Teori cukup. Sekarang kita rapikan latihan sistem stok dari bagian 4. Semua yang berhubungan dengan produk pindah ke package produk: struct, constructor, dan method-nya. File main.go hanya berisi alur program. Ini isi lengkap produk/produk.go.

package produk

import "fmt"

// Produk menyimpan data satu barang di gudang.
type Produk struct {
	Nama  string
	Stok  int
	Harga int
}

// Baru membuat Produk baru dan mengembalikan pointer-nya.
func Baru(nama string, stok int, harga int) *Produk {
	return &Produk{Nama: nama, Stok: stok, Harga: harga}
}

// TambahStok menambah jumlah stok.
func (p *Produk) TambahStok(jumlah int) {
	p.Stok += jumlah
}

// KurangiStok mengurangi stok, gagal kalau stok tidak cukup.
func (p *Produk) KurangiStok(jumlah int) error {
	if jumlah > p.Stok {
		return fmt.Errorf("stok %s tinggal %d, tidak cukup untuk keluar %d",
			p.Nama, p.Stok, jumlah)
	}
	p.Stok -= jumlah
	return nil
}

// Info mengembalikan ringkasan produk dalam satu baris.
func (p *Produk) Info() string {
	return fmt.Sprintf("%s | stok %d | Rp%d", p.Nama, p.Stok, p.Harga)
}

Perhatikan function Baru. Ini pola yang disebut constructor. Dari luar, pemanggilannya jadi produk.Baru(...), enak dibaca seperti kalimat: buat produk baru. Method-nya memakai pointer receiver *Produk supaya perubahan stok benar-benar tersimpan. Itu materi bagian 7 yang langsung terpakai di sini.

Sekarang main.go. Pendek dan bersih.

package main

import (
	"fmt"

	"github.com/budi/tokokita/produk"
)

func main() {
	kopi := produk.Baru("Kopi Arabika", 10, 25000)
	kopi.TambahStok(5)

	err := kopi.KurangiStok(20)
	if err != nil {
		fmt.Println("Gagal:", err)
	}

	err = kopi.KurangiStok(8)
	if err != nil {
		fmt.Println("Gagal:", err)
	}

	fmt.Println(kopi.Info())
}

Jalankan dengan go run . dari folder proyek. Titik di akhir artinya jalankan package di folder ini. Outputnya:

Gagal: stok Kopi Arabika tinggal 15, tidak cukup untuk keluar 20
Kopi Arabika | stok 7 | Rp25000

Logikanya sama persis dengan versi satu file. Yang berubah cuma letaknya. Tapi rasakan bedanya. Kalau besok Anda mau menambah fitur diskon, Anda tahu persis harus buka produk/produk.go. Kalau mau mengubah alur program, buka main.go. Kode soal pelanggan nanti tinggal dibuatkan folder pelanggan sendiri.

Memakai package buatan orang lain

Kekuatan module tidak berhenti di kode sendiri. Dengan go get, Anda bisa memakai ribuan package buatan komunitas. Kita coba satu yang populer dan stabil: github.com/google/uuid, pembuat ID unik. Jalankan dari folder proyek.

go get github.com/google/uuid

Go akan download package itu, lalu mencatatnya di go.mod. File-nya sekarang punya baris baru.

module github.com/budi/tokokita

go 1.22

require github.com/google/uuid v1.6.0

Artinya proyek ini butuh package uuid versi 1.6.0. Selain itu muncul file baru bernama go.sum. Isinya kode hash dari package yang di-download. Fungsinya seperti segel: kalau nanti Anda atau teman satu tim download ulang package itu dan isinya berbeda dari yang tercatat, Go langsung menolak. Dua file ini yang menjamin proyek Anda jalan sama persis di komputer siapa pun. Keduanya wajib ikut di-commit ke Git.

Memakainya sama seperti package lain. Tambahkan di import, panggil function-nya.

import "github.com/google/uuid"

// di dalam function:
id := uuid.NewString()
fmt.Println("ID transaksi:", id)

Setiap dipanggil, uuid.NewString() menghasilkan string acak seperti 3f1c9d2a-8b7e-4f0a-9c2d-1e5b6a7f8d90. Cocok untuk ID transaksi atau nomor pesanan yang tidak boleh kembar.

Kebiasaan penamaan package yang baik

Terakhir, soal nama. Komunitas Go punya selera yang cukup seragam di sini.

• Pendek dan satu kata: produk, laporan, kasir.
• Semua huruf kecil. Tanpa underscore, tanpa camelCase. Bukan dataProduk atau data_produk.
• Nama menggambarkan isi. Orang harus bisa menebak isi package dari namanya saja.
• Hindari pengulangan nama. Function produk.Baru lebih enak daripada produk.ProdukBaru. Nama package sudah memberi konteks, tidak perlu diulang.

Anti-pattern yang paling sering muncul di pemula: package util atau helper. Isinya gado-gado. Format tanggal, hitung pajak, validasi email, semua dilempar ke sana. Enam bulan kemudian package itu jadi tempat sampah yang tidak ada yang berani menyentuh. Kalau ada function yang bingung mau ditaruh di mana, itu tanda Anda belum menemukan nama topik yang tepat, bukan tanda butuh package util. Format tanggal bisa masuk package tanggal. Hitung pajak masuk pajak. Spesifik selalu menang.

Rangkuman dan bagian berikutnya

Hari ini kode Anda naik kelas. Dari satu file main.go menjadi proyek yang tertata. Yang perlu diingat:

• Module adalah KTP proyek. Dibuat dengan go mod init, dicatat di go.mod, dinamai dengan path repo seperti github.com/username/tokokita.
• Satu folder satu package. Kode dikelompokkan per topik, bukan ditumpuk di satu file.
• Huruf besar berarti exported, huruf kecil berarti privat. Itu alasan Println ber-P besar.
• Import package sendiri memakai nama module ditambah nama folder.
• go get menarik package pihak ketiga, tercatat di go.mod dan disegel di go.sum.
• Nama package pendek, huruf kecil, spesifik. Jauhi package util campur aduk.

Coba latihan kecil sebelum lanjut: pecah latihan Anda sendiri dari bagian 5 atau 6 menjadi minimal satu package terpisah, lalu pastikan go run . tetap jalan. Di bagian 9 kita masuk ke salah satu fitur paling khas Go: interface. Judulnya “Interface: Kontrak yang Bikin Kode Fleksibel”. Struktur proyek seperti ini juga yang kami pakai sehari-hari saat membangun sistem aplikasi untuk bisnis dengan Go di Arrazy.

Di Belajar Golang dari Nol #6 kita sudah belajar mengendalikan alur program dengan for dan percabangan. Sekarang kita masuk ke materi yang paling sering bikin pemula gentar sebelum mencoba: pointer. Padahal konsepnya sederhana. Anda hanya perlu satu analogi yang pas, dan sisanya akan terasa masuk akal.

Masih ingat di bagian 4 kita menyinggung pointer receiver saat membahas method, lalu saya janji akan membahasnya tuntas? Ini bagian yang menepati janji itu.

Analogi: Fotokopi Dokumen vs Alamat Rumah

Bayangkan Anda punya dokumen penting di rumah, misalnya sertifikat tanah. Teman Anda butuh dokumen itu. Ada dua cara Anda memberikannya.

Cara pertama, Anda fotokopi dokumennya lalu kirim fotokopiannya. Teman Anda boleh mencoret-coret fotokopian itu sesuka hati. Dokumen asli di rumah Anda tetap aman, tidak berubah sedikit pun.

Cara kedua, Anda kasih alamat rumah Anda. Teman Anda datang ke alamat itu, membuka lemari, dan mengubah dokumen aslinya langsung. Apa pun yang dia tulis di sana, itu terjadi pada dokumen asli.

Di Go, cara pertama adalah perilaku default: setiap nilai yang dioper ke function akan difotokopi. Cara kedua adalah pointer: Anda tidak mengoper nilainya, tapi mengoper alamat tempat nilai itu disimpan di memori. Pegang analogi ini terus. Semua materi di bawah hanyalah variasi dari dua cara itu.

Go Selalu Mengoper Salinan

Mari buktikan dulu perilaku defaultnya. Coba jalankan program ini.

package main

import "fmt"

func tambahBonus(gaji int) {
	gaji = gaji + 500000
	fmt.Println("Di dalam function:", gaji)
}

func main() {
	gaji := 5000000
	tambahBonus(gaji)
	fmt.Println("Di main:", gaji)
}

Outputnya:

Di dalam function: 5500000
Di main: 5000000

Perhatikan baik-baik. Di dalam tambahBonus, nilai gaji memang bertambah jadi 5500000. Tapi begitu kembali ke main, nilainya tetap 5000000. Kenapa? Karena yang diterima function adalah fotokopian. Function mencoret-coret fotokopian itu, lalu fotokopiannya dibuang saat function selesai. Dokumen asli di main tidak pernah tersentuh.

Ini bukan bug. Ini desain Go yang disengaja, namanya pass by value. Tapi kadang kita memang ingin function lain mengubah data asli. Di situlah pointer masuk.

Dua Operator Kunci: & dan *

Untuk bermain dengan alamat memori, Go memberi kita dua operator.

• & artinya “ambil alamat dari variabel ini”. Seperti bertanya, rumah si Budi di mana ya.
• * artinya “buka isi dari alamat ini”. Seperti datang ke alamat itu dan melihat apa yang ada di dalamnya.

Contoh kecilnya begini.

package main

import "fmt"

func main() {
	umur := 25
	alamat := &umur

	fmt.Println("Nilai umur:", umur)
	fmt.Println("Alamat umur:", alamat)
	fmt.Println("Isi dari alamat:", *alamat)
}

Outputnya kira-kira seperti ini:

Nilai umur: 25
Alamat umur: 0xc000012028
Isi dari alamat: 25

Angka 0xc000012028 itu alamat memori. Di komputer Anda angkanya hampir pasti beda, dan tiap kali program dijalankan ulang angkanya juga bisa berubah. Itu normal. Sistem operasi bebas menaruh data di slot memori mana pun yang kosong, sama seperti mobil yang tidak selalu parkir di slot yang sama tiap ke mal.

Variabel alamat di atas bertipe *int, dibaca “pointer ke int”. Artinya dia tidak menyimpan angka 25, dia menyimpan alamat tempat angka 25 berada.

Function yang Benar-Benar Mengubah Nilai

Sekarang gabungkan keduanya. Kalau parameter function bertipe pointer, function itu menerima alamat, bukan fotokopian. Dia bisa datang ke alamat itu dan mengubah dokumen aslinya.

package main

import "fmt"

func ubahNilai(x *int) {
	*x = 100
}

func ubahNilaiBiasa(x int) {
	x = 100
}

func main() {
	angka := 5

	ubahNilaiBiasa(angka)
	fmt.Println("Setelah versi biasa:", angka)

	ubahNilai(&angka)
	fmt.Println("Setelah versi pointer:", angka)
}

Outputnya:

Setelah versi biasa: 5
Setelah versi pointer: 100

Baca ubahNilai pelan-pelan. Parameter x *int artinya x adalah alamat. Baris *x = 100 artinya datang ke alamat itu, lalu tulis 100 di sana. Karena yang diubah adalah isi alamat asli, perubahan itu terlihat dari main. Dan perhatikan cara memanggilnya: ubahNilai(&angka). Kita tidak mengirim angkanya, kita mengirim alamatnya.

Pointer dan Struct: Rahasia di Balik Pointer Receiver

Sekarang kita bayar utang dari bagian 4. Waktu itu Anda sudah lihat method dengan receiver (r *Rekening) dan saya bilang pakai saja dulu, nanti dijelaskan. Ini penjelasannya.

package main

import "fmt"

type Pengguna struct {
	Nama string
}

func (p Pengguna) GantiNamaValue(baru string) {
	p.Nama = baru
}

func (p *Pengguna) GantiNamaPointer(baru string) {
	p.Nama = baru
}

func main() {
	u := Pengguna{Nama: "Budi"}

	u.GantiNamaValue("Andi")
	fmt.Println("Setelah value receiver:", u.Nama)

	u.GantiNamaPointer("Andi")
	fmt.Println("Setelah pointer receiver:", u.Nama)
}

Outputnya:

Setelah value receiver: Budi
Setelah pointer receiver: Andi

Sekarang mekanismenya jelas. Value receiver (p Pengguna) menerima fotokopian struct. Method mengganti nama di fotokopian, fotokopiannya dibuang, struct asli tetap Budi. Persis seperti kasus tambahBonus tadi. Pointer receiver (p *Pengguna) menerima alamat struct asli, jadi perubahannya nyata.

Ada satu kemudahan dari Go yang perlu Anda tahu. Secara teori, untuk mengakses field lewat pointer Anda harus menulis (*p).Nama: buka dulu isi alamatnya, baru ambil fieldnya. Tapi Go tahu itu merepotkan, jadi p.Nama saja sudah cukup. Go otomatis mengerti maksud Anda. Itulah kenapa di dalam GantiNamaPointer kita bisa menulis p.Nama = baru tanpa tanda bintang. Hal yang sama berlaku saat memanggil: u.GantiNamaPointer("Andi") otomatis diterjemahkan Go menjadi (&u).GantiNamaPointer("Andi").

Hati-Hati dengan Nil Pointer

Masih ingat konsep zero value dari bagian 2? Setiap tipe punya nilai awal. Zero value untuk pointer adalah nil, artinya pointer itu belum menunjuk ke alamat mana pun. Seperti secarik kertas alamat yang masih kosong.

Masalah muncul kalau Anda mencoba membuka isi dari alamat kosong.

package main

import "fmt"

func main() {
	var p *int
	fmt.Println(*p)
}

Program ini langsung crash dengan pesan:

panic: runtime error: invalid memory address or nil pointer dereference

Wajar saja. Anda menyuruh Go datang ke sebuah alamat, tapi kertas alamatnya kosong. Mau ke mana? Ini salah satu error paling umum di dunia Go, jadi biasakan mengecek dulu sebelum membuka isi pointer.

package main

import "fmt"

func main() {
	var p *int

	if p != nil {
		fmt.Println("Isi p:", *p)
	} else {
		fmt.Println("p masih nil, belum menunjuk ke mana-mana")
	}
}

Outputnya:

p masih nil, belum menunjuk ke mana-mana

Pola if p != nil ini akan sangat sering Anda temui di kode Go sungguhan, terutama saat menerima pointer dari function lain.

Kapan Pakai Pointer, Kapan Tidak

Supaya tidak bingung di lapangan, pegang aturan praktis ini.

Pakai pointer kalau:

• Anda ingin function atau method mengubah data aslinya, seperti semua contoh di atas.
• Struct Anda besar dan sering dioper ke banyak function. Mengoper alamat jauh lebih ringan daripada memfotokopi seluruh isi struct berulang kali.
• Menjaga konsistensi method. Kalau satu method di sebuah struct sudah pakai pointer receiver, sebaiknya semua method di struct itu pakai pointer receiver juga, biar tidak membingungkan pembaca kode.

Tidak perlu pointer kalau:

• Tipenya kecil seperti int, bool, atau string, dan Anda tidak berniat mengubahnya. Fotokopi tipe kecil itu murah.
• Datanya slice atau map. Ingat pelajaran bagian 5: slice dan map secara internal sudah menunjuk ke data yang sama, jadi perubahan isi di dalam function memang terlihat dari luar tanpa pointer.

Satu hal lagi yang layak disebut singkat: function bawaan new(). Menulis p := new(int) artinya Go membuatkan sebuah int dengan zero value, lalu langsung memberi Anda pointernya. Praktiknya, gaya p := &variabel jauh lebih sering dipakai, jadi cukup kenali saja bahwa new() ada.

Latihan: Sistem Saldo Rekening

Sekarang rangkai semuanya jadi satu program utuh. Kita buat sistem saldo sederhana: struct Rekening, method Setor dan Tarik dengan pointer receiver, plus function TransferDana yang menerima dua pointer sekaligus. Method Tarik mengembalikan error kalau saldo kurang, persis pola error yang Anda pelajari di bagian 3.

package main

import (
	"errors"
	"fmt"
)

type Rekening struct {
	Pemilik string
	Saldo   int
}

func (r *Rekening) Setor(jumlah int) {
	r.Saldo = r.Saldo + jumlah
}

func (r *Rekening) Tarik(jumlah int) error {
	if jumlah > r.Saldo {
		return errors.New("saldo tidak cukup")
	}
	r.Saldo = r.Saldo - jumlah
	return nil
}

func TransferDana(dari *Rekening, ke *Rekening, jumlah int) error {
	err := dari.Tarik(jumlah)
	if err != nil {
		return err
	}
	ke.Setor(jumlah)
	return nil
}

func main() {
	rekeningBudi := Rekening{Pemilik: "Budi", Saldo: 500000}
	rekeningSari := Rekening{Pemilik: "Sari", Saldo: 200000}

	rekeningBudi.Setor(100000)
	fmt.Println("Saldo Budi setelah setor:", rekeningBudi.Saldo)

	err := TransferDana(&rekeningBudi, &rekeningSari, 250000)
	if err != nil {
		fmt.Println("Transfer gagal:", err)
	} else {
		fmt.Println("Transfer 250000 dari Budi ke Sari berhasil")
	}
	fmt.Println("Saldo Budi:", rekeningBudi.Saldo)
	fmt.Println("Saldo Sari:", rekeningSari.Saldo)

	err = TransferDana(&rekeningBudi, &rekeningSari, 1000000)
	if err != nil {
		fmt.Println("Transfer gagal:", err)
	}
	fmt.Println("Saldo Budi:", rekeningBudi.Saldo)
	fmt.Println("Saldo Sari:", rekeningSari.Saldo)
}

Outputnya:

Saldo Budi setelah setor: 600000
Transfer 250000 dari Budi ke Sari berhasil
Saldo Budi: 350000
Saldo Sari: 450000
Transfer gagal: saldo tidak cukup
Saldo Budi: 350000
Saldo Sari: 450000

Telusuri alurnya. Setor menambah saldo Budi jadi 600000, dan perubahannya nyata karena receivernya pointer. TransferDana menerima alamat dua rekening sekaligus, jadi dia bisa mengurangi saldo Budi dan menambah saldo Sari dalam satu function. Transfer kedua gagal karena Budi hanya punya 350000, dan lihat saldonya: tidak ada satu rupiah pun yang berubah saat transfer gagal. Method Tarik menolak duluan sebelum sempat menyentuh apa pun.

Coba modifikasi sendiri sebagai latihan. Misalnya, tambahkan validasi agar jumlah setor tidak boleh negatif, atau buat method Info yang mencetak pemilik dan saldo dengan rapi. Kalau kode Anda berperilaku sesuai dugaan, berarti pointer sudah masuk ke kepala.

Rangkuman dan Lanjut ke Bagian 8

Hari ini Anda belajar bahwa Go mengoper nilai secara fotokopi, pointer adalah cara mengoper alamat aslinya, & mengambil alamat, * membuka isinya, pointer receiver bekerja karena menerima alamat struct asli, dan nil pointer wajib dicek sebelum dibuka. Materi yang katanya menakutkan ternyata cuma soal fotokopi dan alamat rumah.

Sejauh ini semua kode kita masih menumpuk di satu file main.go. Untuk program kecil tidak masalah, tapi program sungguhan butuh struktur. Di bagian 8 kita akan membahas Package dan Go Module: Merapikan Kode ke Banyak File. Sampai ketemu di sana.

Kalau bisnis Anda butuh aplikasi yang dibangun dengan fondasi backend yang rapi seperti ini, tim Arrazy siap bantu lewat layanan pengembangan sistem aplikasi.

Di Belajar Golang dari Nol #5 kita sudah kenalan dengan slice dan map. Waktu itu kita sempat memakai for range sekilas untuk membaca isinya, tapi belum dibedah dalam. Sekarang giliran materi itu dituntaskan. Di bagian keenam ini kita bahas perulangan dan percabangan di Go: for dengan semua bentuknya, for range sampai tuntas, break dan continue, if else, switch, sampai label untuk loop bersarang.

Dua materi ini adalah otot utama program. Hampir semua logika, dari menghitung total belanja sampai menyaring data kotor, dibangun dari perulangan dan percabangan. Jadi kita jalan pelan seperti biasa, satu konsep, satu contoh, langsung praktik.

for, Satu-satunya Perulangan di Go

Kalau kamu pernah menyentuh bahasa lain, mungkin kamu terbiasa dengan while, do while, dan for sebagai tiga hal berbeda. Go memangkas semuanya jadi satu kata kunci saja: for. Tidak ada while di Go. Satu kata kunci, tiga cara pakai.

Bentuk klasik: init, kondisi, post

Ini bentuk yang paling sering kamu temui. Ada tiga bagian yang dipisah titik koma: inisialisasi, kondisi, dan apa yang dilakukan setiap akhir putaran.

package main

import "fmt"

func main() {
	for i := 1; i <= 5; i++ {
		fmt.Println("Putaran ke", i)
	}
}

Bacanya seperti resep: mulai dari i bernilai 1, ulangi selama i masih 5 atau kurang, dan setiap selesai satu putaran tambahkan i sebanyak satu. Program ini mencetak lima baris, dari putaran 1 sampai 5.

Bentuk while: kondisi saja

Buang bagian init dan post, sisakan kondisinya. Hasilnya persis while di bahasa lain.

saldo := 100000
for saldo > 0 {
	fmt.Println("Sisa saldo:", saldo)
	saldo -= 30000
}

Selama saldo masih di atas nol, loop terus jalan. Begitu saldo habis, loop berhenti sendiri. Anggap saja seperti main game dengan koin: selama koin masih ada, kamu boleh main terus.

Bentuk tanpa kondisi: loop tak berujung

Tulis for polos tanpa apa pun, maka loop akan berputar selamanya. Ini bukan bug, ini fitur. Server web misalnya, memang harus terus hidup menunggu request. Tapi untuk program biasa, kamu wajib menyediakan pintu keluar lewat break.

hitung := 0
for {
	hitung++
	fmt.Println("Masih jalan, hitung:", hitung)
	if hitung == 3 {
		break
	}
}

Tanpa break di situ, program ini tidak akan pernah selesai dan terminal kamu penuh angka. Kalau itu terjadi, tekan Ctrl+C untuk menghentikannya.

for range: Cara Nyaman Menyusuri Slice dan Map

Di bagian 5 kita sudah pakai for range sekilas. Sekarang kita bongkar aturannya satu per satu, karena bentuk inilah yang paling sering kamu tulis sehari-hari.

Range pada slice

Saat dipakai pada slice, range memberi dua nilai setiap putaran: index dan isinya.

buah := []string{"mangga", "jeruk", "salak"}

for i, nama := range buah {
	fmt.Println(i, nama)
}

Output:

0 mangga
1 jeruk
2 salak

Sering kali kamu hanya butuh isinya, tidak peduli index-nya. Di sinilah underscore berperan. Tanda _ artinya kamu bilang ke Go: nilai ini sengaja saya abaikan. Ini penting karena Go menolak compile kalau ada variabel yang dideklarasikan tapi tidak dipakai.

for _, nama := range buah {
	fmt.Println(nama)
}

Sebaliknya, kalau kamu cuma butuh index, tulis satu variabel saja: for i := range buah. Nilainya otomatis hanya index.

Range pada map

Pada map, dua nilai yang diberikan adalah key dan value.

stok := map[string]int{
	"mangga": 10,
	"jeruk":  5,
	"salak":  8,
}

for nama, jumlah := range stok {
	fmt.Println(nama, "=", jumlah)
}

Nah, ini catatan yang sering bikin pemula bingung. Urutan hasil range pada map itu acak. Jalankan program yang sama dua kali, urutannya bisa beda. Ini disengaja oleh pembuat Go supaya programmer tidak menggantungkan logika pada urutan map. Jadi kalau output map kamu terlihat berantakan urutannya, program kamu tidak rusak. Memang begitu sifatnya. Kalau butuh urutan yang pasti, kumpulkan dulu key-nya ke slice, urutkan, lalu loop slice itu.

break dan continue

Dua kata ini adalah rem dan gas di dalam loop. break menghentikan loop sepenuhnya. continue melompati sisa putaran saat ini dan langsung lanjut ke putaran berikutnya.

Contoh nyata untuk continue: menyaring data yang tidak valid. Misal kamu punya daftar nilai ujian, tapi ada beberapa angka aneh yang harus dilewati.

nilai := []int{80, -5, 90, 200, 75}

for _, n := range nilai {
	if n < 0 || n > 100 {
		continue
	}
	fmt.Println("Nilai valid:", n)
}

Angka -5 dan 200 dilompati, sisanya dicetak. Sedangkan break cocok saat kamu mencari sesuatu dan ingin berhenti begitu ketemu, supaya tidak buang tenaga memeriksa sisa data.

daftar := []string{"Andi", "Budi", "Citra", "Dewi"}
dicari := "Citra"

for i, nama := range daftar {
	if nama == dicari {
		fmt.Println("Ketemu di index", i)
		break
	}
}

if, else if, dan else

Percabangan di Go bentuknya sederhana. Kondisi tidak perlu tanda kurung, tapi kurung kurawal wajib ada.

skor := 78

if skor >= 85 {
	fmt.Println("Grade A")
} else if skor >= 70 {
	fmt.Println("Grade B")
} else {
	fmt.Println("Belum lulus")
}

Go mengecek dari atas ke bawah dan berhenti di kondisi pertama yang cocok. Skor 78 masuk Grade B, karena syarat Grade A gagal lebih dulu.

if dengan statement pendek

Ini gaya khas Go yang akan sering kamu lihat di kode orang lain. Kamu boleh menaruh satu statement pendek sebelum kondisi, dipisah titik koma. Masih ingat pola comma ok saat mengecek isi map di bagian 5? Biasanya pola itu ditulis begini:

stok := map[string]int{"mangga": 10}

if jumlah, ok := stok["mangga"]; ok {
	fmt.Println("Stok mangga:", jumlah)
} else {
	fmt.Println("Mangga tidak ada di data")
}

Variabel jumlah dan ok lahir di dalam if itu dan hanya hidup di situ. Setelah blok if selesai, keduanya lenyap. Ini bagus, karena variabel bantu tidak berserakan mengotori bagian lain fungsi.

switch: if else Berantai yang Lebih Rapi

Kalau cabangnya banyak, if else berantai mulai capek dibaca. switch hadir untuk itu.

hari := "sabtu"

switch hari {
case "sabtu", "minggu":
	fmt.Println("Akhir pekan")
case "jumat":
	fmt.Println("Sebentar lagi libur")
default:
	fmt.Println("Hari kerja")
}

Perhatikan satu case boleh menampung beberapa nilai sekaligus, dipisah koma. default jalan kalau tidak ada case yang cocok.

Ada satu perbedaan besar dengan bahasa seperti C atau JavaScript: switch di Go tidak butuh break. Begitu satu case cocok dan selesai dijalankan, Go otomatis keluar dari switch. Kamu tidak akan kena bug klasik lupa break yang bikin eksekusi bocor ke case berikutnya. Kalau kamu memang sengaja ingin lanjut ke case di bawahnya, ada kata kunci fallthrough. Cukup tahu saja dulu, praktiknya jarang sekali dipakai.

switch tanpa kondisi

Bentuk ini favorit banyak programmer Go. Tulis switch tanpa apa pun, lalu tiap case berisi kondisi boolean. Hasilnya pengganti if else berantai yang jauh lebih enak dibaca.

skor := 78

switch {
case skor >= 85:
	fmt.Println("Grade A")
case skor >= 70:
	fmt.Println("Grade B")
default:
	fmt.Println("Belum lulus")
}

Sama seperti if else, pengecekan berjalan dari atas ke bawah dan berhenti di yang pertama cocok.

Label: Keluar dari Loop Bersarang

Satu materi kecil sebelum latihan. break biasa hanya menghentikan loop terdalam. Kalau kamu punya loop di dalam loop dan ingin keluar dari semuanya sekaligus, pakai label.

luar:
	for i := 0; i < 3; i++ {
		for j := 0; j < 3; j++ {
			if i*j >= 4 {
				break luar
			}
			fmt.Println(i, j)
		}
	}

break luar langsung melompat keluar dari kedua loop. Jujur saja, label jarang dipakai di kode sehari-hari. Cukup tahu bahwa fitur ini ada, supaya tidak bingung saat menemukannya di kode orang lain.

Latihan: Rekap Penjualan Mingguan

Sekarang kita gabungkan semua materi hari ini plus struct dari bagian 4 dan slice dari bagian 5. Skenarionya: kamu punya catatan transaksi toko selama seminggu. Sebagian transaksi batal dan harus dilewati. Sisanya dihitung totalnya, dirata-rata, dan diberi kategori nominal pakai switch.

package main

import "fmt"

type Transaksi struct {
	ID     int
	Produk string
	Nilai  int
	Batal  bool
}

func main() {
	transaksi := []Transaksi{
		{ID: 1, Produk: "Kaos Polos", Nilai: 150000, Batal: false},
		{ID: 2, Produk: "Jaket Hoodie", Nilai: 450000, Batal: false},
		{ID: 3, Produk: "Topi Baseball", Nilai: 75000, Batal: true},
		{ID: 4, Produk: "Celana Chino", Nilai: 320000, Batal: false},
		{ID: 5, Produk: "Kemeja Flanel", Nilai: 260000, Batal: false},
		{ID: 6, Produk: "Sandal Jepit", Nilai: 35000, Batal: true},
		{ID: 7, Produk: "Sepatu Lari", Nilai: 780000, Batal: false},
	}

	total := 0
	jumlahValid := 0

	fmt.Println("=== Rekap Penjualan Mingguan ===")

	for _, t := range transaksi {
		if t.Batal {
			fmt.Printf("Transaksi #%d (%s) batal, dilewati\n", t.ID, t.Produk)
			continue
		}

		var kategori string
		switch {
		case t.Nilai >= 500000:
			kategori = "besar"
		case t.Nilai >= 200000:
			kategori = "sedang"
		default:
			kategori = "kecil"
		}

		fmt.Printf("#%d %-15s Rp%-8d kategori %s\n", t.ID, t.Produk, t.Nilai, kategori)

		total += t.Nilai
		jumlahValid++
	}

	fmt.Println("--------------------------------")
	fmt.Println("Transaksi valid :", jumlahValid)
	fmt.Println("Total penjualan : Rp", total)

	if jumlahValid > 0 {
		rata := total / jumlahValid
		fmt.Println("Rata-rata       : Rp", rata)
	}
}

Jalankan dengan go run main.go. Hasilnya:

=== Rekap Penjualan Mingguan ===
#1 Kaos Polos      Rp150000   kategori kecil
#2 Jaket Hoodie    Rp450000   kategori sedang
Transaksi #3 (Topi Baseball) batal, dilewati
#4 Celana Chino    Rp320000   kategori sedang
#5 Kemeja Flanel   Rp260000   kategori sedang
Transaksi #6 (Sandal Jepit) batal, dilewati
#7 Sepatu Lari     Rp780000   kategori besar
--------------------------------
Transaksi valid : 5
Total penjualan : Rp 1960000
Rata-rata       : Rp 392000

Coba telusuri alurnya pelan-pelan. Loop for range menyusuri slice of struct. continue melewati dua transaksi yang batal, jadi keduanya tidak ikut total. Switch tanpa kondisi memberi label kategori berdasarkan nominal. Terakhir, if di bawah memastikan pembagian rata-rata hanya jalan kalau ada transaksi valid, supaya program tidak membagi dengan nol.

Sebagai latihan mandiri, coba ubah programnya sedikit. Tambahkan variabel penghitung untuk tiap kategori, lalu cetak berapa transaksi besar, sedang, dan kecil di bagian rekap. Semua bahannya sudah kamu pegang.

Rangkuman dan Bagian Selanjutnya

Hari ini kamu sudah menguasai alat kontrol alur di Go:

• for adalah satu-satunya perulangan, dengan tiga bentuk: klasik, gaya while, dan tanpa kondisi
• for range menyusuri slice dan map, dengan catatan urutan map selalu acak
• break menghentikan loop, continue melompati satu putaran
• if bisa membawa statement pendek, cocok untuk pola comma ok
• switch di Go otomatis berhenti per case, tanpa perlu break, dan bentuk tanpa kondisinya menggantikan if else berantai
• label dipakai untuk keluar dari loop bersarang, meski jarang dibutuhkan

Di bagian 7 kita masuk ke topik yang sering dianggap seram padahal sebenarnya ramah: Pointer di Go: Memahami Alamat Memori Tanpa Pusing. Sampai ketemu di sana.

Seri ini ditulis dari pengalaman tim Arrazy membangun berbagai sistem aplikasi untuk bisnis di Indonesia.

Di Belajar Golang dari Nol #4 kita sudah belajar membungkus data ke dalam struct dan menempelkan method padanya. Satu struct mewakili satu barang, satu user, atau satu produk. Tapi program nyata jarang mengurus satu data saja. Toko punya banyak produk. Sekolah punya banyak siswa. Kita butuh wadah untuk menampung kumpulan data. Di Go, dua wadah yang paling sering dipakai adalah slice dan map. Keduanya jadi menu utama kita hari ini.

Sekilas tentang array

Sebelum masuk ke slice, kenalan dulu dengan fondasinya, yaitu array. Array adalah deretan data dengan ukuran tetap. Sekali dibuat berisi 3 slot, selamanya 3 slot.

var nilai [3]int
nilai[0] = 80
nilai[1] = 75
nilai[2] = 90

Bayangkan rak dengan jumlah laci yang sudah dipatok dari pabrik. Mau menambah laci keempat, tidak bisa. Karena kaku seperti itu, array jarang dipakai langsung dalam kode Go sehari-hari. Yang hampir selalu dipakai adalah slice, yang di belakang layar sebenarnya menumpang pada array. Cukup tahu itu dulu. Fokus kita sekarang ke slice.

Slice, daftar yang bisa memanjang

Slice mirip daftar belanja di kertas. Awalnya berisi tiga barang. Ingat sesuatu, tulis lagi di bawahnya. Daftarnya memanjang sendiri tanpa perlu ganti kertas.

Membuat slice hampir sama dengan array, hanya tanpa angka di dalam kurung siku.

package main

import "fmt"

func main() {
	buah := []string{"apel", "mangga", "jeruk"}

	fmt.Println(buah)      // [apel mangga jeruk]
	fmt.Println(len(buah)) // 3
	fmt.Println(buah[0])   // apel
	fmt.Println(buah[2])   // jeruk
}

Tiga hal yang perlu dicatat dari kode di atas.

• []string{...} disebut slice literal. Kita langsung mengisi datanya saat membuat.
• len(buah) menghitung jumlah isi slice.
• buah[0] mengakses isi berdasarkan posisi. Posisi dihitung dari 0, bukan dari 1.

Untuk menambah isi, pakai append.

buah = append(buah, "salak")
fmt.Println(buah)      // [apel mangga jeruk salak]
fmt.Println(len(buah)) // 4

Perhatikan polanya. Hasil append harus disimpan kembali ke variabelnya. Menulis append(buah, "salak") saja tanpa menampung hasilnya tidak akan mengubah apa pun, dan Go bahkan menolaknya saat compile. Anggap append seperti fotokopi daftar lama plus satu baris baru. Daftar barunya harus kita pegang.

Slice juga bisa dipotong. Sintaksnya a[awal:akhir]. Posisi awal ikut diambil, posisi akhir tidak.

potongan := buah[1:3]
fmt.Println(potongan) // [mangga jeruk]

buah[1:3] artinya ambil mulai posisi 1 sampai sebelum posisi 3. Jadi posisi 1 dan 2 saja. Awalnya sering bikin bingung, tapi lama-lama terasa natural.

Slice berisi struct

Di bagian 4 kita sudah bisa membuat struct Produk. Sekarang gabungkan. Slice tidak hanya bisa menampung string atau angka. Ia bisa menampung struct. Inilah cara Go menyimpan daftar produk, daftar siswa, atau daftar transaksi.

package main

import "fmt"

type Produk struct {
	Nama  string
	Harga int
}

func main() {
	daftar := []Produk{
		{Nama: "Kopi Bubuk", Harga: 25000},
		{Nama: "Gula Pasir", Harga: 15000},
		{Nama: "Teh Celup", Harga: 10000},
	}

	for _, p := range daftar {
		fmt.Println(p.Nama, "harganya Rp", p.Harga)
	}
}

Baris for _, p := range daftar artinya kunjungi setiap isi slice satu per satu, lalu simpan isinya ke variabel p. Tanda _ dipakai karena kita tidak butuh nomor urutnya. Detail lengkap soal for dan range kita bahas tuntas di bagian 6. Sekarang cukup pahami bahwa pola ini dipakai untuk menelusuri isi slice.

Map, mencari data lewat kunci

Slice mencari data lewat posisi. Map mencari data lewat kunci. Bayangkan loker di kolam renang. Anda tidak menghafal loker keberapa dari kiri. Anda cukup pegang kuncinya, lalu langsung buka loker yang cocok. Kunci pada map bisa berupa string, misalnya nama barang, dan nilainya bisa apa saja.

Bentuk penulisannya map[tipeKunci]tipeNilai. Contoh map untuk mencatat stok barang.

package main

import "fmt"

func main() {
	stok := map[string]int{
		"kopi": 10,
		"gula": 5,
	}

	// menambah data baru
	stok["teh"] = 8

	// mengubah data yang sudah ada
	stok["kopi"] = 12

	// menghapus data
	delete(stok, "gula")

	fmt.Println(stok)        // map[kopi:12 teh:8]
	fmt.Println(stok["teh"]) // 8
}

Menambah dan mengubah pakai sintaks yang sama, yaitu stok["kunci"] = nilai. Kalau kuncinya belum ada, data baru dibuat. Kalau sudah ada, nilainya ditimpa. Menghapus pakai fungsi bawaan delete.

Comma ok, cara aman mengecek isi map

Sekarang bagian penting. Apa yang terjadi kalau kita membaca kunci yang tidak ada?

fmt.Println(stok["beras"]) // 0

Go tidak error. Ia mengembalikan zero value dari tipe nilainya. Masih ingat materi zero value di bagian 2? Untuk int, zero value adalah 0. Di sinilah masalahnya. Angka 0 itu ambigu. Apakah beras memang tidak terdaftar, atau beras terdaftar tapi stoknya sedang kosong? Dua kondisi yang sangat berbeda, hasilnya sama-sama 0.

Go menyediakan cara untuk membedakannya. Namanya comma ok idiom.

jumlah, ok := stok["beras"]
if ok {
	fmt.Println("beras terdaftar, stok:", jumlah)
} else {
	fmt.Println("beras tidak terdaftar di toko")
}

Saat membaca map dengan dua variabel penampung, variabel kedua berisi true kalau kuncinya memang ada, dan false kalau tidak. Dengan begitu kita tidak lagi tertipu oleh zero value. Biasakan pakai pola ini setiap kali keberadaan kunci itu penting untuk logika program. Di program latihan nanti, pola ini yang membedakan barang habis dengan barang yang memang tidak dijual.

Map dengan value struct

Sama seperti slice, nilai pada map juga boleh berupa struct. Cocok untuk katalog, di mana nama barang jadi kunci dan detailnya jadi nilai.

katalog := map[string]Produk{
	"kopi": {Nama: "Kopi Bubuk", Harga: 25000},
	"gula": {Nama: "Gula Pasir", Harga: 15000},
}

fmt.Println(katalog["kopi"].Harga) // 25000

Sekali akses, kita langsung dapat struct utuh lengkap dengan semua field-nya.

Kapan pakai slice, kapan pakai map

Aturan praktisnya sederhana.

• Pakai slice kalau urutan itu penting atau data memang berbentuk antrean. Daftar transaksi, riwayat chat, isi keranjang belanja. Data tersimpan berurutan dan boleh ada isi yang kembar.
• Pakai map kalau Anda sering mencari data berdasarkan kunci tertentu. Stok per nama barang, user per email, konfigurasi per nama setting. Aksesnya langsung ketemu tanpa menelusuri satu per satu, tapi urutannya tidak dijamin.

Satu catatan soal urutan. Saat map ditelusuri dengan range, Go sengaja mengacak urutannya. Jadi jangan pernah mengandalkan urutan pada map. Kalau butuh urutan, pakailah slice. Keduanya juga sering dipakai bersamaan dalam satu program, seperti yang akan kita lakukan di latihan.

Dua jebakan yang sering menjerat pemula

Nil map tidak bisa diisi

Kalau map hanya dideklarasikan tanpa diinisialisasi, nilainya nil. Membaca nil map masih aman, hasilnya zero value. Tapi menulis ke nil map membuat program langsung panic alias berhenti mendadak.

var umur map[string]int
umur["budi"] = 20 // panic: assignment to entry in nil map

Solusinya, siapkan map-nya dulu dengan make atau dengan literal kosong.

umur := make(map[string]int)
umur["budi"] = 20 // aman

Anggap make seperti memasang papan loker sebelum kunci pertama dibagikan. Slice lebih pemaaf di sini, karena append pada slice nil tetap aman. Map tidak. Ini salah satu penyebab panic paling umum pada program Go pemula.

Slice yang berbagi data

Jebakan kedua lebih halus. Hasil pemotongan slice tidak menyalin data. Ia menunjuk ke deretan data yang sama dengan slice asalnya. Mengubah satu, yang lain ikut berubah.

angka := []int{1, 2, 3, 4}
potongan := angka[0:2]
potongan[0] = 99

fmt.Println(potongan) // [99 2]
fmt.Println(angka)    // [99 2 3 4]

Perhatikan, angka ikut berubah padahal kita hanya mengubah potongan. Keduanya memandang lemari data yang sama dari jendela yang berbeda. Ini bukan bug, ini memang desain Go supaya pemotongan slice murah dan cepat. Tapi kalau tidak sadar, efek samping seperti ini bisa bikin bingung berjam-jam. Kalau memang butuh salinan yang benar-benar terpisah, Go punya fungsi copy yang bisa Anda eksplorasi sendiri.

Latihan: keranjang belanja mini

Waktunya merangkai semua materi hari ini jadi satu program utuh. Kita buat keranjang belanja mini dengan aturan begini. Stok barang tersimpan di map. Katalog produk tersimpan di map dengan value struct. Isi keranjang tersimpan di slice. Fungsi penambah barang wajib mengecek dulu lewat comma ok, supaya barang yang tidak dijual dan barang yang stoknya habis diperlakukan beda.

package main

import "fmt"

type Produk struct {
	Nama  string
	Harga int
}

func tambahKeKeranjang(keranjang []Produk, stok map[string]int, katalog map[string]Produk, nama string) []Produk {
	sisa, ok := stok[nama]
	if !ok {
		fmt.Println(nama, ": barang tidak ada di toko")
		return keranjang
	}
	if sisa == 0 {
		fmt.Println(nama, ": stok sedang habis")
		return keranjang
	}

	stok[nama] = sisa - 1
	keranjang = append(keranjang, katalog[nama])
	fmt.Println(nama, ": masuk keranjang")
	return keranjang
}

func main() {
	stok := map[string]int{
		"kopi": 2,
		"gula": 0,
		"teh":  5,
	}

	katalog := map[string]Produk{
		"kopi": {Nama: "Kopi Bubuk", Harga: 25000},
		"gula": {Nama: "Gula Pasir", Harga: 15000},
		"teh":  {Nama: "Teh Celup", Harga: 10000},
	}

	var keranjang []Produk
	keranjang = tambahKeKeranjang(keranjang, stok, katalog, "kopi")
	keranjang = tambahKeKeranjang(keranjang, stok, katalog, "teh")
	keranjang = tambahKeKeranjang(keranjang, stok, katalog, "gula")
	keranjang = tambahKeKeranjang(keranjang, stok, katalog, "beras")

	fmt.Println()
	fmt.Println("Isi keranjang:")
	total := 0
	for _, p := range keranjang {
		fmt.Println("-", p.Nama, "Rp", p.Harga)
		total = total + p.Harga
	}
	fmt.Println("Total belanja: Rp", total)
}

Jalankan dengan go run main.go. Hasilnya seperti ini.

kopi : masuk keranjang
teh : masuk keranjang
gula : stok sedang habis
beras : barang tidak ada di toko

Isi keranjang:
- Kopi Bubuk Rp 25000
- Teh Celup Rp 10000
Total belanja: Rp 35000

Coba telusuri alurnya pelan-pelan. Kopi dan teh masuk keranjang karena kuncinya ada dan stoknya lebih dari 0. Gula ditolak dengan pesan stok habis, karena comma ok mengembalikan true tapi sisanya 0. Beras ditolak dengan pesan berbeda, karena comma ok mengembalikan false. Tanpa idiom itu, gula dan beras akan terlihat sama persis di mata program. Perhatikan juga bahwa tambahKeKeranjang mengembalikan slice baru dan hasilnya selalu kita tampung lagi, konsisten dengan pola append yang tadi kita bahas.

Sebagai latihan tambahan, coba dua hal ini. Pertama, tambahkan barang baru ke katalog dan stok, lalu beli beberapa kali sampai stoknya habis. Kedua, ubah program supaya satu barang bisa dibeli dengan jumlah tertentu sekaligus, bukan satu-satu.

Selanjutnya di seri ini

Anda sekarang pegang dua wadah data paling penting di Go. Slice untuk daftar yang berurutan, map untuk pencarian cepat lewat kunci, plus comma ok untuk membaca map dengan aman. Sepanjang artikel ini kita sudah beberapa kali memakai for range dan if tanpa membedahnya dalam-dalam. Itu sengaja. Di bagian 6, Perulangan for dan Percabangan: Mengendalikan Alur Program, keduanya kita kupas tuntas, mulai dari berbagai bentuk for sampai switch. Sampai jumpa di bagian berikutnya.

Kalau bisnis Anda butuh aplikasi dengan pengelolaan data seperti ini, mulai dari katalog produk sampai sistem stok, tim kami siap membantu lewat layanan pengembangan sistem aplikasi.