Blog

Di Belajar Golang dari Nol #2 kamu sudah pegang variabel, tipe data, zero value, dan konversi tipe. Di sana kamu juga sempat ketemu sekilas dengan if err != nil waktu memakai strconv.Atoi. Waktu itu saya minta kamu terima dulu polanya tanpa banyak tanya. Sekarang saatnya membongkar asal-usulnya. Di bagian ini kita belajar function, multiple return, dan cara Go memperlakukan error.

Function: bungkus logika biar bisa dipakai ulang

Bayangkan function seperti mesin jus. Kamu masukkan buah, mesin bekerja, keluar jus. Kamu tidak perlu tahu isi mesinnya setiap kali mau bikin jus. Cukup tahu apa yang dimasukkan dan apa yang keluar.

Di Go, bentuk dasarnya seperti ini.

func sapa(nama string) string {
    return "Halo, " + nama
}

Baca pelan-pelan dari kiri ke kanan. func adalah kata kunci untuk membuat function. sapa adalah namanya. nama string artinya function ini menerima satu parameter bernama nama yang bertipe string. string di paling kanan adalah tipe nilai balikannya. Lalu return mengirim nilai itu keluar ke pemanggil.

Kalau kamu pernah lihat Java atau C, urutannya terasa terbalik, karena Go memang sengaja menaruh tipe setelah nama supaya deklarasi tetap enak dibaca saat mulai kompleks.

Begini cara memanggilnya dalam program utuh.

package main

import "fmt"

func sapa(nama string) string {
    return "Halo, " + nama
}

func main() {
    pesan := sapa("Sari")
    fmt.Println(pesan)
}

Jalankan dengan go run main.go, hasilnya:

Halo, Sari

Parameter dan return value

Function boleh menerima lebih dari satu parameter. Kita coba function hitung sederhana.

func luasPersegiPanjang(panjang int, lebar int) int {
    return panjang * lebar
}

Ada satu trik kecil yang sering kamu temui di kode Go orang lain. Kalau beberapa parameter bertipe sama, tipenya cukup ditulis sekali di belakang.

func luasPersegiPanjang(panjang, lebar int) int {
    return panjang * lebar
}

Keduanya sama persis artinya. Memanggilnya juga biasa saja: luas := luasPersegiPanjang(8, 5) akan mengisi luas dengan 40. Sampai sini belum ada yang aneh. Bagian menariknya baru mulai sekarang.

Multiple return: ciri khas Go

Di kebanyakan bahasa, function hanya bisa mengembalikan satu nilai. Go berbeda. Satu function boleh mengembalikan dua nilai atau lebih sekaligus. Ini bukan sekadar fitur gaya-gayaan. Ini fondasi dari cara Go menangani error.

Contoh paling klasik adalah pembagian. Membagi angka dengan nol itu operasi yang tidak sah. Jadi function pembagi kita sebaiknya menjawab dua hal: berapa hasilnya, dan apakah operasinya berhasil.

package main

import (
    "errors"
    "fmt"
)

func bagi(a, b float64) (float64, error) {
    if b == 0 {
        return 0, errors.New("tidak bisa membagi dengan nol")
    }
    return a / b, nil
}

func main() {
    hasil, err := bagi(10, 2)
    if err != nil {
        fmt.Println("terjadi error:", err)
        return
    }
    fmt.Println("hasil:", hasil)
}

Perhatikan bagian (float64, error). Itu artinya function ini mengembalikan dua nilai: hasil pembagian bertipe float64, dan sebuah error. Kalau semuanya lancar, error yang dikembalikan adalah nil, yang artinya kosong, tidak ada masalah. Kalau ada masalah, kita kembalikan nilai error yang berisi pesan.

Di sisi pemanggil, dua nilai itu ditangkap sekaligus: hasil, err := bagi(10, 2). Ini pola yang akan kamu tulis ratusan kali selama menulis Go, jadi biasakan dari sekarang.

Konvensi error di Go

Di Go, error bukan sesuatu yang spesial. Error adalah nilai biasa, sama seperti angka atau string, hanya saja tipenya error. Karena dia nilai biasa, dia bisa dikembalikan dari function, disimpan di variabel, atau dibandingkan.

Ada beberapa konvensi tidak tertulis yang dipegang hampir semua programmer Go:

• Kalau function bisa gagal, nilai balikan terakhirnya bertipe error. Bukan yang pertama, bukan di tengah. Selalu yang terakhir.
• Untuk membuat error dengan pesan tetap, pakai errors.New("pesan errornya") dari package errors.
• Untuk pesan yang butuh format, pakai fmt.Errorf. Misalnya fmt.Errorf("stok tinggal %d", sisa).

Satu hal lagi yang cukup kamu tahu namanya dulu. fmt.Errorf punya kata kerja format khusus, yaitu %w, yang dipakai untuk membungkus error lain di dalam error baru. Teknik ini namanya error wrapping, dan detailnya kita bahas di bagian lanjutan seri ini. Sekarang cukup ingat bahwa %w itu ada.

Pola if err != nil, dijelaskan tuntas

Sekarang kita jawab pertanyaan yang tertunda dari bagian 2: kenapa kode Go penuh dengan if err != nil?

Bahasa seperti Java, Python, atau JavaScript memakai try-catch. Kamu tulis kode di blok try, dan kalau ada yang meledak di mana pun di dalamnya, eksekusi melompat ke blok catch. Go mengambil jalan lain. Tidak ada try-catch. Function yang bisa gagal mengembalikan error sebagai nilai, dan kamu memeriksanya langsung setelah pemanggilan.

Alasannya soal kejujuran kode. Dengan try-catch, kamu bisa memanggil sepuluh function tanpa tahu mana yang bisa gagal. Di Go, kemungkinan gagal tertulis jelas di tanda tangan function. Pembaca kode langsung tahu titik mana saja yang bisa bermasalah, dan compiler akan protes kalau kamu menangkap err lalu tidak menyentuhnya sama sekali.

Supaya adil, pendekatan ini ada harganya. Kode Go jadi lebih panjang, dan mengetik if err != nil berulang-ulang memang terasa repetitif. Ini kritik paling umum terhadap Go, dan kritik itu valid. Sebagian orang menganggapnya bertele-tele, sebagian lagi justru menyukainya karena alur kegagalan terlihat gamblang tanpa lompatan tersembunyi. Setelah beberapa minggu menulis Go, kebanyakan orang berhenti menganggapnya masalah.

Pola pendampingnya bernama early return: begitu ketemu error, langsung return dan hentikan function. Kode sukses tidak perlu dibungkus blok else, jadi alur utamanya tetap lurus dari atas ke bawah. Contohnya sudah kamu lihat di function main tadi. Kalau err tidak nil, cetak pesannya lalu return. Baris di bawahnya hanya berjalan saat semuanya aman.

Named return: singkat saja

Go mengizinkan nilai balikan diberi nama di tanda tangan function.

func bagi(a, b float64) (hasil float64, err error) {
    if b == 0 {
        err = errors.New("tidak bisa membagi dengan nol")
        return
    }
    hasil = a / b
    return
}

hasil dan err otomatis menjadi variabel di dalam function, dan return polos akan mengembalikan nilai keduanya saat itu. Kelihatan praktis, tapi pada function yang panjang, pembaca harus menebak apa isi return polos itu. Saran saya untuk sekarang: tulis return secara eksplisit seperti contoh-contoh sebelumnya. Named return baru berguna di kasus khusus yang akan kamu temui jauh di depan.

Variadic function: parameter yang jumlahnya bebas

Kadang kamu tidak tahu berapa banyak nilai yang akan dikirim ke function. Menjumlahkan isi keranjang belanja, misalnya. Bisa dua barang, bisa sepuluh. Untuk itu Go punya variadic function, ditandai tiga titik sebelum tipe.

func totalBelanja(harga ...int) int {
    total := 0
    for _, h := range harga {
        total += h
    }
    return total
}

harga ...int artinya function ini menerima nol, satu, atau banyak nilai int. Di dalam function, harga berperilaku seperti kumpulan nilai yang bisa kita jelajahi dengan for range. Perulangan sendiri akan kita kupas dalam di bagian lain, untuk sekarang cukup pahami bahwa baris itu mengunjungi tiap harga satu per satu dan menambahkannya ke total.

Memanggilnya luwes sekali: totalBelanja(15000, 20000) sah, totalBelanja(5000, 7500, 12000, 3000) juga sah. fmt.Println yang kamu pakai sejak bagian 1 juga variadic. Itu sebabnya dia mau menerima berapa pun argumen.

Latihan: kalkulator diskon

Sekarang kita rangkai semuanya jadi satu program utuh. Skenarionya sederhana: kasir menjumlahkan keranjang belanja, lalu menerapkan diskon. Diskon di bawah 0 persen atau di atas 100 persen jelas tidak masuk akal, jadi harus ditolak lewat error.

package main

import "fmt"

func totalKeranjang(harga ...float64) float64 {
    total := 0.0
    for _, h := range harga {
        total += h
    }
    return total
}

func hitungDiskon(total, persen float64) (float64, error) {
    if persen < 0 {
        return 0, fmt.Errorf("persen diskon tidak boleh negatif, dapat %v", persen)
    }
    if persen > 100 {
        return 0, fmt.Errorf("persen diskon tidak boleh lebih dari 100, dapat %v", persen)
    }
    potongan := total * persen / 100
    return total - potongan, nil
}

func main() {
    total := totalKeranjang(15000, 42500, 8000)
    fmt.Println("Total keranjang:", total)

    bayar, err := hitungDiskon(total, 20)
    if err != nil {
        fmt.Println("Gagal menghitung diskon:", err)
        return
    }
    fmt.Println("Bayar setelah diskon 20 persen:", bayar)

    bayar, err = hitungDiskon(total, 150)
    if err != nil {
        fmt.Println("Gagal menghitung diskon:", err)
        return
    }
    fmt.Println("Bayar setelah diskon 150 persen:", bayar)
}

Jalankan, dan outputnya seperti ini.

Total keranjang: 65500
Bayar setelah diskon 20 persen: 52400
Gagal menghitung diskon: persen diskon tidak boleh lebih dari 100, dapat 150

Mari bedah sebentar apa yang terjadi:

• totalKeranjang adalah variadic function. Dia menerima tiga harga dan menjumlahkannya jadi 65500.
• hitungDiskon memakai multiple return: hasil bertipe float64 plus error di posisi terakhir, sesuai konvensi.
• Validasi dilakukan di awal function dengan early return. Persen 20 lolos, jadi errornya nil dan program mencetak 52400.
• Panggilan kedua mengirim persen 150. Validasi menolaknya, err terisi, dan blok if err != nil mencetak pesan lalu menghentikan main. Baris cetak “Bayar setelah diskon 150 persen” tidak pernah dijalankan.

Coba ubah sendiri: ganti persen jadi -5, tambah barang di keranjang, atau buat function baru hitungPajak dengan pola yang sama. Semakin sering tanganmu menulis pola ini, semakin cepat dia jadi refleks.

Rangkuman dan lanjut ke mana

Hari ini kamu sudah belajar cukup banyak:

• Function dideklarasikan dengan func, dan tipe ditulis setelah nama.
• Function di Go bisa mengembalikan lebih dari satu nilai.
• Konvensi error: nilai balikan terakhir bertipe error, dibuat dengan errors.New atau fmt.Errorf.
• Go memilih pengecekan error eksplisit lewat if err != nil plus early return, bukan try-catch.
• Named return ada, tapi untuk sekarang lebih baik return eksplisit.
• Variadic function menerima jumlah argumen yang bebas.

Dengan bekal ini, kamu sudah bisa memecah program jadi potongan-potongan kecil yang rapi dan tahan gagal. Di bagian berikutnya kita naik satu tingkat: “Belajar Golang dari Nol #4: Struct dan Method: Cara Go Menyusun Data”. Di sana function yang baru kamu kuasai akan menempel langsung ke data.

Pola function dan error yang kamu latih hari ini persis pola yang kami pakai sehari-hari saat membangun backend produksi dengan Go untuk klien Arrazy.

Di Belajar Golang dari Nol #1 kamu sudah install Go dan menjalankan program pertama lewat go run. Sekarang kita masuk ke bahan bangunan paling dasar dari semua program: variabel, tipe data, dan satu konsep khas Go yang namanya zero value.

Anggap variabel itu seperti kotak berlabel. Labelnya nama variabel, isinya nilai. Bedanya dengan bahasa lain, di Go setiap kotak juga punya aturan ketat soal barang apa yang boleh masuk. Kotak untuk angka tidak bisa diisi teks. Aturan ini yang bikin program Go jarang error aneh saat sudah jalan.

Tiga Cara Deklarasi Variabel di Go

Go punya tiga gaya untuk membuat variabel. Semuanya sering dipakai, jadi kenali satu per satu.

1. var tanpa nilai awal

var nama string
var umur int

fmt.Println(nama) // (string kosong)
fmt.Println(umur) // 0

Di sini kamu hanya menyiapkan kotaknya. Isinya belum ada, tapi Go otomatis memberi nilai default. Soal nilai default ini kita bahas lebih dalam di bagian zero value nanti.

2. var dengan nilai awal

var nama string = "Rizky"
var umur = 25 // tipe int ditebak otomatis oleh Go

Kalau nilai awal sudah ada, kamu boleh menulis tipenya atau membiarkan Go menebak sendiri. Menebak tipe dari nilai ini disebut type inference. Nilai 25 otomatis dianggap int, nilai "Rizky" otomatis dianggap string.

3. Short declaration dengan :=

nama := "Rizky"
umur := 25

Ini cara paling ringkas dan paling sering kamu lihat di kode Go sehari-hari. Tanda := artinya “buat variabel baru sekaligus isi nilainya”. Tanpa kata var, tanpa menulis tipe.

Ada satu aturan penting: := hanya boleh dipakai di dalam function. Di luar function, misalnya di level package, kamu wajib pakai var. Kode di bawah ini menunjukkan bedanya.

package main

import "fmt"

var appName = "Kasir Sederhana" // level package, wajib var

func main() {
	versi := "1.0" // di dalam function, boleh :=
	fmt.Println(appName, versi)
}

Lalu kapan pakai yang mana? Panduan sederhananya begini:

• Pakai := untuk variabel biasa di dalam function. Ini pilihan default kamu.
• Pakai var kalau kamu butuh variabel di level package, atau kalau kamu sengaja ingin variabel kosong dulu dan diisi belakangan.
• Pakai var dengan tipe eksplisit kalau tipe tebakan Go bukan yang kamu mau. Misalnya var saldo float64 = 10000, karena saldo := 10000 akan jadi int.

Tipe Data Dasar yang Wajib Kamu Kenal

Go punya banyak tipe data. Untuk sekarang, empat tipe ini cukup untuk hampir semua latihan awal.

string

Teks. Selalu ditulis dengan tanda kutip dua, bukan kutip satu.

namaToko := "Kopi Senja"
alamat := "Jl. Merdeka No. 10, Purwokerto"

int

Bilangan bulat. Cocok untuk hal yang dihitung satuan: jumlah barang, umur, jumlah user.

stok := 120
jumlahKaryawan := 8

Go juga punya varian seperti int8, int32, dan int64. Angka di belakangnya menunjukkan berapa bit memori yang dipakai, yang menentukan seberapa besar angka yang bisa ditampung. int64 misalnya sering dipakai untuk ID di database yang nilainya bisa sangat besar. Untuk belajar, pakai int biasa saja dulu. Sisanya akan terasa gunanya saat kamu mulai kerja dengan database atau API.

float64

Bilangan desimal. Cocok untuk harga, berat, rating, dan apa pun yang punya koma.

hargaKopi := 25000.0
beratBiji := 0.25 // kg

Perhatikan 25000.0. Titik nol di belakang itu penting. Tanpa itu, Go menganggapnya int. Dengan titik desimal, Go tahu kamu mau float64.

bool

Nilai benar atau salah. Isinya cuma dua kemungkinan: true atau false.

sudahBayar := true
tokoTutup := false

Tipe ini kelihatan sepele, tapi hampir semua logika program dibangun di atasnya. Setiap if yang kamu tulis nanti ujungnya selalu sebuah bool.

Zero Value: Nilai Default yang Bikin Tenang

Sekarang konsep khas Go yang tadi sempat disinggung. Di Go, variabel yang dideklarasikan tanpa nilai awal tidak pernah kosong tanpa arti. Go selalu mengisinya dengan nilai default sesuai tipenya. Nilai default ini disebut zero value.

• string menjadi "" (string kosong)
• int dan float64 menjadi 0
• bool menjadi false
• tipe seperti pointer, slice, dan map menjadi nil

Coba jalankan program kecil ini dan lihat hasilnya.

package main

import "fmt"

func main() {
	var nama string
	var stok int
	var harga float64
	var aktif bool

	fmt.Printf("nama: %q\n", nama)
	fmt.Printf("stok: %d\n", stok)
	fmt.Printf("harga: %f\n", harga)
	fmt.Printf("aktif: %t\n", aktif)
}

Outputnya:

nama: ""
stok: 0
harga: 0.000000
aktif: false

Kenapa ini desain yang enak? Karena kamu tidak pernah perlu bertanya “variabel ini sudah diisi atau belum, isinya sampah memori atau bukan”. Setiap variabel selalu punya nilai yang jelas dan bisa diprediksi sejak lahir. Kalau kamu pernah pegang JavaScript, ini beda jauh dengan undefined yang sering muncul tiba-tiba di tempat yang tidak kamu duga.

Zero value juga sering dimanfaatkan langsung. Counter mulai dari 0, flag mulai dari false, teks mulai dari kosong. Banyak kode Go sengaja didesain agar zero value-nya langsung berguna tanpa perlu setup tambahan.

Konstanta: Nilai yang Dikunci

Kadang ada nilai yang tidak boleh berubah selama program berjalan. Rate diskon, nama aplikasi, batas maksimal upload. Untuk itu Go punya const.

const appName = "Kasir Senja"
const diskonMember = 0.1
const maksimalQty = 100

Bedanya dengan var ada dua. Pertama, nilai const harus sudah diketahui saat program di-compile, jadi kamu tidak bisa mengisinya dari input user atau hasil pemanggilan function biasa. Kedua, nilainya terkunci. Kalau kamu coba mengubahnya, program tidak akan bisa di-compile.

const diskonMember = 0.1
diskonMember = 0.2 // error: cannot assign to diskonMember

Ini bagus. Lebih baik error muncul saat compile daripada diam-diam ada kode yang mengubah rate diskon di tengah jalan. Aturan praktisnya: kalau sebuah nilai memang tidak akan pernah berubah, jadikan const. Sisanya baru var atau :=.

Konversi Tipe: Go Itu Ketat, dan Itu Bagus

Go tidak mau menebak-nebak saat dua tipe berbeda bertemu. Operasi int dicampur float64 langsung ditolak compiler. Kamu harus konversi dulu secara eksplisit.

qty := 3          // int
harga := 12500.0  // float64

// total := qty * harga        // error: mismatched types
total := float64(qty) * harga  // benar: 37500

Polanya sederhana: tulis nama tipe tujuan, lalu bungkus nilainya dengan tanda kurung. float64(qty) artinya “ubah qty menjadi float64”. Berlaku juga sebaliknya, int(harga), dengan catatan angka di belakang koma akan dibuang.

Angka ke string dan sebaliknya dengan strconv

Untuk konversi antara angka dan string, tipe castingnya berbeda urusan. string(65) tidak menghasilkan teks “65”, tapi karakter dengan kode 65. Yang benar, pakai package strconv dari standard library.

package main

import (
	"fmt"
	"strconv"
)

func main() {
	// int ke string: Itoa (Integer to ASCII)
	umur := 25
	teksUmur := strconv.Itoa(umur)
	fmt.Println("Umur saya " + teksUmur + " tahun")

	// string ke int: Atoi (ASCII to Integer)
	angka, err := strconv.Atoi("123")
	if err != nil {
		fmt.Println("Gagal konversi:", err)
		return
	}
	fmt.Println("Hasil tambah satu:", angka+1)
}

Perhatikan baris angka, err := strconv.Atoi("123"). Kenapa hasilnya dua? Karena konversi string ke angka bisa gagal. String "123" jelas bisa jadi angka, tapi bagaimana dengan "abc"? Go menjawab kemungkinan gagal itu dengan mengembalikan dua nilai: hasilnya dan errornya. Kalau konversi sukses, err bernilai nil. Kalau gagal, err berisi keterangan kegagalannya dan kamu wajib menanganinya.

Pola if err != nil ini akan kamu tulis ratusan kali sepanjang karier Go kamu. Ini cara Go memaksa programmer memikirkan kegagalan sejak awal, bukan menundanya sampai program crash di production. Detail cara kerja multiple return dan error akan kita kupas tuntas di bagian 3. Untuk sekarang, cukup hafalkan bentuknya.

Kenalan dengan fmt.Printf

Sebelum masuk latihan, kenalan dulu dengan fmt.Printf. Kalau fmt.Println mencetak apa adanya, Printf mencetak dengan format yang kamu atur lewat kode persen. Yang paling sering dipakai:

• %s untuk string
• %d untuk bilangan bulat
• %f untuk desimal, dan %.2f untuk membatasi dua angka di belakang koma
• %t untuk bool
• %v untuk nilai apa pun, berguna saat malas mikir tipenya

nama := "Rizky"
qty := 3
harga := 12500.0
member := true

fmt.Printf("%s beli %d barang seharga %.2f, member: %t\n", nama, qty, harga, member)
// Rizky beli 3 barang seharga 12500.00, member: true

Jangan lupa \n di akhir untuk pindah baris. Printf tidak menambahkannya otomatis seperti Println.

Latihan: Program Hitung Total Belanja

Sekarang gabungkan semua materi jadi satu program utuh. Kasusnya sederhana: hitung total belanja satu barang, lalu beri diskon 10 persen kalau pembelinya member. Buat file main.go baru, ketik ulang kodenya sendiri, jangan copy paste. Mengetik ulang itu cara belajar paling cepat.

package main

import "fmt"

const diskonMember = 0.1 // 10 persen, dikunci dengan const

func main() {
	// data belanja
	namaBarang := "Kopi Arabika 200g" // string
	qty := 3                          // int
	harga := 45000.0                  // float64
	isMember := true                  // bool

	// qty harus dikonversi dulu agar bisa dikali float64
	subtotal := float64(qty) * harga

	// zero value float64 adalah 0, jadi non-member otomatis diskonnya 0
	var diskon float64
	if isMember {
		diskon = subtotal * diskonMember
	}

	total := subtotal - diskon

	// cetak struk
	fmt.Println("===== Struk Belanja =====")
	fmt.Printf("Barang   : %s\n", namaBarang)
	fmt.Printf("Qty      : %d\n", qty)
	fmt.Printf("Harga    : Rp%.0f\n", harga)
	fmt.Printf("Subtotal : Rp%.0f\n", subtotal)
	fmt.Printf("Member   : %t\n", isMember)
	fmt.Printf("Diskon   : Rp%.0f\n", diskon)
	fmt.Printf("Total    : Rp%.0f\n", total)
}

Jalankan dengan go run main.go. Outputnya:

===== Struk Belanja =====
Barang   : Kopi Arabika 200g
Qty      : 3
Harga    : Rp45000
Subtotal : Rp135000
Member   : true
Diskon   : Rp13500
Total    : Rp121500

Lihat bagaimana semua materi hari ini terpakai. Ada const untuk rate diskon, := untuk variabel di dalam function, empat tipe data dasar, konversi float64(qty), zero value yang dimanfaatkan di variabel diskon, dan Printf untuk merapikan output.

Sebagai latihan tambahan, coba ubah isMember jadi false dan jalankan lagi. Perhatikan diskon otomatis jadi 0 tanpa kamu menulis kode tambahan. Itu zero value yang bekerja untukmu. Lalu coba ganti qty := 3 menjadi qty := 3.0 dan lihat error apa yang muncul. Membaca pesan error compiler sejak dini akan sangat membantu di bagian-bagian berikutnya.

Lanjut ke Bagian 3

Hari ini kamu sudah pegang fondasi terpenting: tiga cara deklarasi variabel, empat tipe data dasar, zero value, konstanta, konversi tipe, dan kenalan pertama dengan pola if err != nil. Semua program Go, sesederhana atau serumit apa pun, dibangun dari bahan-bahan ini.

Di bagian berikutnya kita masuk ke topik yang membuat kode kamu mulai terstruktur: “Belajar Golang dari Nol #3: Function, Multiple Return, dan Error Pertamamu”. Di sana misteri kenapa Atoi mengembalikan dua nilai akan terjawab tuntas.

Seri ini kami tulis dari pengalaman sehari-hari, karena tim Arrazy memang membangun backend produksi dengan Go untuk berbagai sistem aplikasi klien kami.

Go (sering disebut Golang) adalah bahasa pemrograman open source yang dibuat di Google oleh Robert Griesemer, Rob Pike, dan Ken Thompson, lalu dirilis ke publik tahun 2009. Bahasa ini dirancang untuk satu hal: membuat software yang cepat dan mudah dirawat, tanpa ritual yang ribet. Di dunia nyata, Go paling sering dipakai untuk backend API, tool CLI, dan service yang butuh performa tinggi. Google jelas memakainya. Uber memakainya untuk banyak microservice mereka. Di Indonesia, Gojek dan Tokopedia sudah lama menjadikan Go tulang punggung backend mereka.

Jadi kalau kamu ingin serius di dunia backend, Go adalah salah satu pilihan paling masuk akal saat ini. Seri “Belajar Golang dari Nol” ini akan menemani kamu dari titik paling awal: belum pernah menyentuh Go sama sekali. Mungkin kamu baru bisa sedikit PHP atau JavaScript. Tidak masalah. Kita mulai pelan.

Kenapa Go Enak untuk Pemula Backend

Ada beberapa alasan kenapa saya suka merekomendasikan Go sebagai bahasa backend pertama atau kedua.

• Kompilasinya cepat. Kamu edit kode, jalankan, hasilnya muncul dalam hitungan detik. Siklus coba-salah-perbaiki jadi singkat, dan itu penting banget saat belajar.
• Hasilnya satu binary. Saat kamu build program Go, hasilnya satu file executable yang bisa langsung dijalankan di server. Tidak perlu install runtime, interpreter, atau setumpuk dependency di server tujuan. Kalau kamu terbiasa dengan PHP yang butuh web server plus interpreter di sisi produksi, ini rasanya seperti pindah dari koper besar ke satu tas selempang.
• Sintaksnya kecil. Go hanya punya 25 keyword. Bandingkan dengan bahasa lain yang bisa dua kali lipatnya. Artinya, hal yang perlu kamu hafal sedikit. Kode Go milik orang lain juga gampang dibaca karena semua orang menulis dengan gaya yang kurang lebih sama.
• Ada garbage collector. Kamu tidak perlu mengatur memori secara manual seperti di C. Go yang membereskan memori yang sudah tidak terpakai. Kamu fokus ke logika program saja.

Biar adil, Go juga punya sisi yang kurang enak. Pertama, kodenya cenderung verbose. Hal yang di JavaScript bisa satu baris, di Go kadang butuh lima baris. Kedua, error handling-nya berulang. Kamu akan sering sekali menulis pola if err != nil sampai hafal di luar kepala. Sebagian orang menganggap ini membosankan. Tapi ada hikmahnya: kamu dipaksa memikirkan setiap kemungkinan error, dan itu kebiasaan bagus untuk programmer backend.

Cara Install Go

Semua file instalasi resmi ada di satu tempat: go.dev/dl. Jangan unduh dari tempat lain. Pilih bagian sesuai sistem operasi kamu di bawah ini.

Install Go di Linux

Di Linux, cara paling bersih adalah memakai tarball resmi. Hindari install dari apt bawaan distro karena versinya sering tertinggal jauh.

Pertama, unduh tarball dari go.dev/dl. Cek dulu nomor versi terbaru di halaman itu, lalu sesuaikan nama filenya. Contoh di bawah memakai versi 1.25.1 untuk arsitektur amd64:

wget https://go.dev/dl/go1.25.1.linux-amd64.tar.gz

Kedua, hapus instalasi Go lama (kalau ada) dan ekstrak ke /usr/local:

sudo rm -rf /usr/local/go
sudo tar -C /usr/local -xzf go1.25.1.linux-amd64.tar.gz

Perintah tar -C /usr/local artinya ekstrak isi arsip ke folder /usr/local. Hasilnya, Go terpasang di /usr/local/go.

Ketiga, tambahkan Go ke PATH. PATH itu daftar folder tempat terminal mencari program saat kamu mengetik sebuah perintah. Kalau folder bin milik Go tidak ada di PATH, terminal tidak akan kenal perintah go. Buka file ~/.bashrc (atau ~/.zshrc kalau kamu pakai zsh), lalu tambahkan baris ini di paling bawah:

export PATH=$PATH:/usr/local/go/bin

Simpan, lalu muat ulang konfigurasi shell:

source ~/.bashrc

Kalau pakai zsh, ganti dengan source ~/.zshrc.

Install Go di Windows

Di Windows jauh lebih sederhana:

• Buka go.dev/dl lalu unduh file installer berakhiran .msi untuk Windows.
• Jalankan file itu dengan klik dua kali, lalu ikuti wizard-nya. Klik Next terus sampai selesai. Secara default Go terpasang di C:\Program Files\Go.
• Installer ini otomatis mengatur PATH untukmu, jadi tidak ada langkah manual tambahan.

Satu catatan penting: setelah instalasi selesai, tutup semua jendela Command Prompt atau PowerShell yang sedang terbuka, lalu buka yang baru. Terminal yang sudah terbuka sebelum instalasi belum membaca PATH yang baru.

Install Go di macOS

Kalau kamu sudah pakai Homebrew, satu perintah ini cukup:

brew install go

Homebrew akan mengurus PATH secara otomatis. Kalau belum pakai Homebrew, alternatifnya unduh installer .pkg dari go.dev/dl, klik dua kali, lalu ikuti wizard-nya seperti install aplikasi Mac pada umumnya.

Verifikasi Instalasi

Apa pun sistem operasinya, cara mengeceknya sama. Buka terminal baru, lalu ketik:

go version

Kalau instalasi berhasil, kamu akan melihat output kurang lebih seperti ini:

go version go1.25.1 linux/amd64

Nomor versi dan nama platformnya bisa berbeda sesuai apa yang kamu install. Yang penting perintah itu mengeluarkan versi, bukan pesan “command not found”. Kalau muncul “command not found” di Linux atau macOS, kemungkinan besar masalahnya di langkah PATH tadi. Cek lagi apakah baris export sudah tersimpan dan kamu sudah menjalankan source atau membuka terminal baru.

Oh ya, kalau kamu sempat baca tutorial Go yang lama, mungkin kamu menemukan pembahasan panjang soal GOPATH dan struktur folder yang wajib diikuti. Abaikan saja. Sejak Go versi modern memakai sistem module, kamu bisa menaruh proyek di folder mana pun yang kamu suka. Tidak perlu setting tambahan apa-apa lagi setelah langkah instalasi di atas.

Program Go Pertama: Hello World

Sekarang bagian paling menyenangkan. Buat folder baru untuk latihan, misalnya halo-go, lalu masuk ke dalamnya:

mkdir halo-go
cd halo-go

Buat file bernama main.go dengan teks editor favoritmu (VS Code juga boleh), lalu isi dengan kode ini:

package main

import "fmt"

func main() {
	fmt.Println("Halo, Go!")
}

Enam baris saja, tapi setiap barisnya punya makna. Mari kita bedah satu per satu.

package main

Setiap file Go wajib diawali deklarasi package. Package itu semacam label yang mengelompokkan file-file kode yang saling berhubungan. Nah, package main punya arti khusus: ini penanda bahwa program kamu adalah program yang bisa dijalankan langsung, bukan sekadar pustaka yang dipakai program lain. Anggap saja seperti label “pintu masuk utama” pada sebuah gedung.

import “fmt”

Baris ini mengambil package fmt dari pustaka standar Go. Nama fmt singkatan dari format, isinya fungsi-fungsi untuk mencetak dan memformat teks. Tanpa baris import ini, kamu tidak bisa memakai fmt.Println. Go bahkan menolak kompilasi kalau kamu meng-import package yang tidak dipakai. Ketat memang, tapi hasilnya kode kamu selalu bersih dari import sampah.

func main()

func adalah kata kunci untuk mendefinisikan fungsi. Fungsi bernama main di dalam package main adalah titik awal eksekusi program. Saat program dijalankan, Go langsung mencari fungsi ini dan mengeksekusi isinya baris per baris. Satu program hanya boleh punya satu func main.

fmt.Println(“Halo, Go!”)

Ini isi programnya: memanggil fungsi Println milik package fmt untuk mencetak teks ke layar, lalu pindah ke baris baru. Pola namaPackage.NamaFungsi ini akan sangat sering kamu temui di Go.

Menjalankan Program: go run vs go build

Ada dua cara menjalankan program Go, dan keduanya penting kamu pahami. Cara pertama, go run:

go run main.go

Outputnya:

Halo, Go!

Perintah go run mengompilasi kode ke file sementara, menjalankannya, lalu membuang hasil kompilasinya. Cocok untuk fase belajar dan development karena praktis: satu perintah, langsung lihat hasil.

Cara kedua, go build:

go build -o halo main.go

Perintah ini mengompilasi kode dan menyimpan hasilnya sebagai file executable bernama halo (flag -o menentukan nama outputnya). Di Windows hasilnya halo.exe. Sekarang jalankan binary itu:

./halo

Di Windows cukup ketik halo. Hasilnya sama: teks “Halo, Go!” muncul di layar.

Bedanya apa? go run itu seperti masak lalu langsung makan di dapur. go build seperti masak lalu mengemas makanannya rapi dalam kotak, siap dibawa dan dimakan di mana saja. File hasil go build bisa kamu salin ke server atau komputer lain yang bahkan tidak punya Go terinstall, dan program tetap jalan. Inilah keunggulan “satu binary” yang saya sebut di awal, dan alasan kenapa deployment aplikasi Go terkenal simpel.

Persiapan Bagian 2: go mod init

Satu hal lagi sebelum kita tutup. Proyek Go modern selalu diawali dengan membuat module. Module itu semacam identitas proyek plus catatan dependency-nya, mirip peran package.json di dunia Node.js. Di dalam folder proyekmu, jalankan:

go mod init halo-go

Perintah ini membuat file go.mod yang berisi nama module dan versi Go yang dipakai. Untuk latihan lokal, nama module bebas. Nanti kalau proyekmu dipublikasikan, biasanya nama module memakai alamat repositori seperti github.com/username/nama-proyek. Untuk sekarang, cukup tahu bahwa setiap proyek Go yang serius dimulai dengan go mod init. Kita akan memakainya terus di sepanjang seri ini.

Sampai Ketemu di Bagian 2

Sampai di sini kamu sudah punya Go yang terpasang rapi, paham struktur dasar sebuah program Go, dan tahu bedanya go run dengan go build. Itu fondasi yang cukup kuat untuk melangkah.

Di bagian berikutnya, “Belajar Golang dari Nol #2: Variabel, Tipe Data, dan Zero Value di Go”, kita mulai menulis kode yang sesungguhnya: menyimpan data, mengenal tipe-tipe bawaan Go, dan memahami konsep zero value yang membuat Go beda dari kebanyakan bahasa lain. Sambil menunggu, coba ubah-ubah program hello world tadi. Ganti teksnya, tambah baris Println lain, lalu build ulang. Membiasakan jari itu bagian dari belajar.

Seri ini kami tulis dari pengalaman langsung, karena tim Arrazy memakai Go untuk membangun backend produksi milik klien lewat layanan pengembangan sistem aplikasi.