Variabel di Golang: var, :=, Zero Value, dan Shadowing

Go punya dua cara untuk mendeklarasikan variabel: var, yang bisa dipakai di mana saja, dan :=, bentuk singkat yang bisa dipakai di dalam fungsi dan menebak tipenya secara otomatis.

package main

import "fmt"

func main() {
	var city string = "Lisbon" // explicit type and value
	var year = 2026            // type inferred as int
	var score int              // no value: zero value 0
	name := "Ana"              // short declaration, inferred string

	fmt.Println(city, year, score, name)
	fmt.Printf("%T %T %T %T\n", city, year, score, name)
}

Setiap variabel punya tipe tetap yang ditentukan saat kompilasi. Saat kamu memberi nilai, Go menebak tipenya dari nilai itu, jadi menulis tipenya juga (var city string = "Lisbon") memang sah tetapi berlebihan.

var vs :=

Pilihan yang idiomatis di dalam fungsi:

• x := value kalau kamu punya nilai awal.
• var x T kalau kamu menginginkan zero value, yang menandakan "sengaja kosong": var buf bytes.Buffer, var total int.
• var x T = value kalau tipe hasil tebakan bukan tipe yang kamu inginkan, misalnya var ratio float64 = 1 (ratio := 1 biasa akan bertipe int).

:= di luar fungsi adalah syntax error:

./main.go:5:1: syntax error: non-declaration statement outside function body

Zero value

Variabel yang dideklarasikan tanpa nilai tidak pernah berisi sampah. Variabel itu berisi zero value dari tipenya:

package main

import "fmt"

type Point struct {
	X, Y int
}

func main() {
	var i int
	var f float64
	var b bool
	var s string
	var p *int
	var sl []int
	var m map[string]int
	var pt Point

	fmt.Println(i, f, b, s == "", p, sl == nil, m == nil, pt)
	fmt.Println(len(sl), len(m), m["missing"])
}

API Go yang baik dirancang agar zero value-nya berguna: sync.Mutex yang bernilai nol dalam keadaan tidak terkunci, bytes.Buffer yang bernilai nol kosong dan siap dipakai, dan len, range, serta append semuanya bisa dipakai pada slice nil. Yang perlu diwaspadai adalah map: membaca map nil mengembalikan zero value, tetapi menulis ke map nil akan panic. Buat map dengan make atau literal sebelum menyimpan isinya.

Mendeklarasikan beberapa variabel

package main

import "fmt"

var (
	appName = "inventory"
	version = "1.4.0"
	debug   bool
)

func main() {
	var width, height int = 1920, 1080
	x, y := 3, 4
	first, count := "widget", 12

	fmt.Println(appName, version, debug)
	fmt.Println(width, height, x, y, first, count)

	// swap without a temporary variable
	x, y = y, x
	fmt.Println("after swap:", x, y)
}

Blok var ( ... ) mengelompokkan variabel di level package yang saling terkait. Dalam assignment ganda seperti x, y = y, x, setiap ekspresi di sisi kanan dievaluasi sebelum ada yang di-assign, dan itulah sebabnya pertukaran nilai ini berhasil.

:= dengan beberapa nama tidak mendeklarasikan ulang apa pun selama minimal satu nama di sisi kiri adalah nama baru. Nama yang sudah ada di scope yang sama hanya diberi nilai baru. Inilah yang memungkinkan kamu memakai ulang err:

f, err := os.Open("a.txt")   // declares f and err
g, err := os.Open("b.txt")   // declares g, assigns to the existing err

Kalau tidak ada satu pun nama yang baru, hasilnya error:

./main.go:7:4: no new variables on left side of :=

Pakai = biasa untuk memberi nilai ke variabel yang sudah ada.

Variabel yang tidak dipakai adalah error

Variabel lokal yang dideklarasikan tetapi tidak pernah dibaca akan menghentikan build:

./main.go:9:2: declared and not used: x

Ini bukan peringatan yang bisa kamu matikan. Hapus variabelnya, pakai, atau, saat sedang debugging, bungkam dengan blank identifier: _ = x. Blank identifier juga membuang nilai kembalian yang tidak kamu butuhkan: _, err := fmt.Println("hi").

Variabel di level package dan parameter fungsi dikecualikan dari aturan ini.

Scope dan shadowing

Sebuah variabel ada sejak deklarasinya sampai akhir blok yang membungkusnya ({ ... }). := di dalam blok yang lebih dalam membuat variabel baru, walaupun ada variabel dengan nama yang sama di luar. Variabel di luar itu tertutupi (shadowed), bukan diubah:

package main

import (
	"fmt"
	"strconv"
)

func main() {
	count := 0
	input := "42"

	if input != "" {
		count, err := strconv.Atoi(input) // new count, only inside this block
		if err != nil {
			fmt.Println("error:", err)
			return
		}
		fmt.Println("inside:", count)
	}

	fmt.Println("outside:", count) // still 0
}

Program ini mencetak inside: 42 lalu outside: 0. := di dalam if mendeklarasikan count dan err sebagai variabel baru di blok dalam, karena keduanya belum ada di sana. Kode ini bisa dikompilasi tanpa masalah dan menjadi sumber klasik bug "nilaiku hilang".

Cara memperbaikinya adalah mendeklarasikan err lebih dulu dan memberi nilai dengan =:

var err error
count, err = strconv.Atoi(input)

go vet tidak melaporkan shadowing secara default. Analyzer shadow yang terpisah bisa melakukannya, dan linter seperti golangci-lint bisa mengaktifkannya.

Penamaan

• Pakai camelCase: maxRetries, userID. Bukan max_retries.
• Tulis akronim dalam satu jenis huruf: userID, httpClient, parseURL, bukan userId.
• Nama pendek untuk scope yang pendek: i di perulangan, r untuk reader, err untuk error. Nama yang lebih panjang dan deskriptif untuk variabel di level package.
• Nama yang diawali huruf besar di level package (var Timeout) diekspor ke package lain. Lihat halaman package dan import.

Variabel di level package

Variabel yang dideklarasikan di luar fungsi hidup selama program berjalan dan diinisialisasi sebelum main dijalankan, sesuai urutan ketergantungannya. Variabel ini praktis untuk konfigurasi dan cache, dan dipakai bersama oleh semua goroutine. Kalau lebih dari satu goroutine menulis ke variabel seperti itu, lindungi dengan mutex atau pakai sync/atomic, karena kalau tidak, akan terjadi data race.

Pakai konstanta untuk nilai yang tidak pernah berubah. const tidak bisa diubah secara tidak sengaja dan tidak ada biayanya saat program berjalan.