vandy

Belajar Golang dari Nol #2: Variabel, Tipe Data, dan Zero Value

Solusi IT

Written by

in

,

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.

Comments

Leave a Reply

Your email address will not be published. Required fields are marked *

More posts