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) // 0Di 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 GoKalau 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 := 25Ini 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
varkalau kamu butuh variabel di level package, atau kalau kamu sengaja ingin variabel kosong dulu dan diisi belakangan. - Pakai
vardengan tipe eksplisit kalau tipe tebakan Go bukan yang kamu mau. Misalnyavar saldo float64 = 10000, karenasaldo := 10000akan jadiint.
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 := 8Go 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 // kgPerhatikan 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 := falseTipe 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.
stringmenjadi""(string kosong)intdanfloat64menjadi0boolmenjadifalse- 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: falseKenapa 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 = 100Bedanya 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 diskonMemberIni 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: 37500Polanya 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:
%suntuk string%duntuk bilangan bulat%funtuk desimal, dan%.2funtuk membatasi dua angka di belakang koma%tuntuk bool%vuntuk 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: trueJangan 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 : Rp121500Lihat 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.