Const di Golang: Konstanta Bertipe dan Tanpa Tipe

Konstanta adalah nilai yang sudah tetap saat kompilasi. Deklarasikan dengan const, dan Go akan menolak setiap upaya untuk mengubahnya.

package main

import (
	"fmt"
	"time"
)

const AppName = "inventory"
const MaxRetries = 3
const Timeout = 2 * time.Second

const (
	KB = 1024
	MB = 1024 * KB
	GB = 1024 * MB
)

func main() {
	fmt.Println(AppName, MaxRetries, Timeout)
	fmt.Println("1 GB =", GB, "bytes")
	fmt.Printf("upload limit: %.1f MB\n", 15_000_000.0/MB)
}

Konstanta bisa dideklarasikan di level package atau di dalam fungsi, satu per baris atau dikelompokkan dalam blok const ( ... ). MB dan GB dihitung dari konstanta lain, dan compiler melakukan aritmetika itu sekali saja, saat build.

Meng-assign nilai ke konstanta, seperti MaxRetries = 5, adalah error kompilasi:

./main.go:8:2: cannot assign to MaxRetries (neither addressable nor a map index expression)

Apa yang Bisa Menjadi Konstanta

Hanya tiga jenis nilai: boolean, angka (integer, float, bilangan kompleks, dan rune) dan string. Nilainya harus bisa dihitung oleh compiler, artinya literal, konstanta lain, aritmetika atas keduanya, dan beberapa fungsi bawaan seperti len dari string konstanta.

Apa pun yang perlu menjalankan kode atau mengalokasikan memori tidak bisa:

const Colors = []string{"red", "green"} // slice
const Started = time.Now()              // function call

./main.go:9:16: []string{…} (value of type []string) is not constant
./main.go:10:13: time.Now() (value of struct type time.Time) is not constant

Kenapa Go Tidak Punya Konstanta Slice atau Map

Slice, map, dan struct yang berisi keduanya adalah referensi ke memori yang ada saat program berjalan, jadi compiler tidak bisa menanamkannya ke dalam program sebagai nilai tetap, dan Go tidak punya modifier readonly atau final untuk variabel. Cara mengakalinya yang umum:

package main

import (
	"fmt"
	"slices"
)

// A package-level var: fine when your own code is the only writer.
var weekdays = []string{"Mon", "Tue", "Wed", "Thu", "Fri"}

// A function returning a fresh copy: callers cannot change the original.
func Weekdays() []string {
	return slices.Clone(weekdays)
}

// An array has a fixed length, but it is still a var, not a const.
var primes = [5]int{2, 3, 5, 7, 11}

func main() {
	days := Weekdays()
	days[0] = "Monday" // changes the copy only

	fmt.Println(days)
	fmt.Println(weekdays)
	fmt.Println(primes, len(primes))
}

Salinan itu butuh satu alokasi per pemanggilan, dan itu tidak masalah untuk data seukuran konfigurasi. Untuk pencarian berdasarkan key, switch di dalam fungsi adalah pilihan lain yang mirip konstanta: func statusText(code int) string { switch code { ... } }.

Konstanta Tanpa Tipe

Konstanta yang dideklarasikan tanpa tipe disebut untyped (tanpa tipe). Konstanta ini punya jenis (integer, float, rune, string, bool) tetapi belum punya tipe Go tertentu sampai dipakai, dan ia menyesuaikan diri dengan konteksnya:

package main

import "fmt"

const Ratio = 2 // untyped integer constant

func main() {
	var a int = Ratio
	var b float64 = Ratio
	var c uint8 = Ratio
	var d float32 = Ratio * 1.5

	fmt.Println(a, b, c, d)
	fmt.Printf("%T %T %T %T\n", a, b, c, d)

	// When nothing forces a type, the default type is used.
	x := Ratio
	y := Ratio * 1.5
	fmt.Printf("x is %T, y is %T\n", x, y)
}

Ratio bisa dipakai sebagai int, float64, uint8, dan float32 tanpa konversi. Karena itulah time.Sleep(2 * time.Second) bisa dikompilasi: 2 tidak bertipe dan menjadi time.Duration.

Kalau konteksnya tidak menuntut tipe tertentu, seperti pada x := Ratio, konstanta itu mendapat tipe default:

Aritmetika eksak

Konstanta numerik tanpa tipe bersifat eksak. Compiler merepresentasikan integer dengan minimal 256 bit, jadi nilai di tengah perhitungan bisa jauh lebih besar dari tipe Go mana pun:

package main

import "fmt"

const Huge = 1 << 100
const Scaled = Huge >> 98 // 4: fits in an int

func main() {
	fmt.Println(Scaled)
	fmt.Println(Huge / (1 << 90)) // 1024
}

Huge sendiri tidak bisa dicetak sebagai integer, karena mengirimnya ke fmt.Println mengonversinya ke int, dan compiler menangkap hal itu (float64(Huge) bisa, karena float sanggup menampung besarnya):

cannot use Huge (untyped int constant 1267650600228229401496703205376) as int value in argument to fmt.Println (overflows)

Pemeriksaan yang sama menghentikan kesalahan yang lebih kecil saat kompilasi, seperti var b byte = 300:

cannot use 300 (untyped int constant) as byte value in variable declaration (overflows)

Konstanta Bertipe

Beri konstanta sebuah tipe dan ia akan berperilaku seperti nilai bertipe itu di mana pun, termasuk penolakan Go untuk mencampur tipe:

const Limit int = 10

var f float64 = 2
fmt.Println(Limit * f)

invalid operation: Limit * f (mismatched types int and float64)

Dengan const Limit = 10 (tanpa tipe), Limit * f bisa dikompilasi dan menghasilkan 20. Jadi biarkan konstanta tanpa tipe kecuali tipenya punya makna. Tipe punya makna saat kamu mendeklarasikan konstanta dengan tipe bernama milikmu sendiri, dan begitulah cara Go membangun enum:

type Weekday int

const (
	Sunday Weekday = iota
	Monday
	Tuesday
)

Di sini tipenya justru intinya: fungsi yang menerima Weekday mendokumentasikan apa yang ia butuhkan. iota dan pola enum yang dibangun di atasnya dibahas di halaman enum dan iota.

const vs var

Pakai const untuk apa pun yang benar-benar tetap: batas, ukuran, nama, kode protokol, string format. Kamu mendapat pemeriksaan overflow saat kompilasi dan aritmetika eksak secara gratis.

Hal yang Sering Menjebak

Konstanta bertipe tidak menyesuaikan diri. const Timeout int = 5 tidak bisa dikirim ke tempat yang mengharapkan time.Duration tanpa konversi; const Timeout = 5 yang tanpa tipe bisa dikalikan: Timeout * time.Second.

Pembagian integer terjadi pada konstanta integer. const Half = 1 / 2 bernilai 0, karena kedua operand adalah integer tanpa tipe. Tulis 1.0 / 2 untuk mendapat 0.5.

Tidak punya alamat. &MaxRetries tidak bisa dikompilasi. Kalau sebuah API meminta *int, salin dulu konstantanya ke sebuah variabel.