Stałe w Go (Golang const): stałe typowane i beztypowe

Stała to wartość ustalona w czasie kompilacji. Deklarujesz ją przez const, a Go odrzuca każdą próbę jej zmiany.

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)
}

Stałe można deklarować na poziomie pakietu lub wewnątrz funkcji, po jednej w linii albo zgrupowane w bloku const ( ... ). MB i GB są obliczane z innych stałych, a kompilator wykonuje te obliczenia raz, podczas budowania.

Przypisanie do stałej, na przykład MaxRetries = 5, to błąd kompilacji:

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

Co może być stałą

Tylko trzy rodzaje wartości: wartości logiczne, liczby (całkowite, zmiennoprzecinkowe, zespolone i runy) oraz stringi. Wartość musi dać się obliczyć przez kompilator, czyli mogą to być literały, inne stałe, działania na nich i kilka funkcji wbudowanych, jak len ze stałego stringa.

Wszystko, co wymaga uruchomienia kodu lub alokacji pamięci, odpada:

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

Dlaczego Go nie ma stałych slice'ów ani map

Slice'y, mapy i struktury, które je zawierają, to referencje do pamięci istniejącej w czasie działania, więc kompilator nie może wbudować ich w program jako stałych wartości, a Go nie ma modyfikatora readonly ani final dla zmiennych. Typowe obejścia:

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))
}

Kopia kosztuje jedną alokację na wywołanie, co jest w porządku przy danych wielkości konfiguracji. Do wyszukiwania po kluczu inną opcją przypominającą stałą jest switch w funkcji: func statusText(code int) string { switch code { ... } }.

Stałe beztypowe

Stała zadeklarowana bez typu jest beztypowa (untyped). Ma rodzaj (liczba całkowita, zmiennoprzecinkowa, runa, string, bool), ale nie ma konkretnego typu Go, dopóki nie zostanie użyta, i dopasowuje się do kontekstu:

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 działa jako int, float64, uint8 i float32 bez konwersji. Dlatego time.Sleep(2 * time.Second) się kompiluje: 2 jest beztypowe i staje się time.Duration.

Gdy kontekst nie wymaga typu, jak w x := Ratio, stała dostaje swój typ domyślny:

Dokładna arytmetyka

Beztypowe stałe liczbowe są dokładne. Kompilator reprezentuje liczby całkowite na co najmniej 256 bitach, więc wartości pośrednie mogą być dużo większe niż jakikolwiek typ Go:

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
}

Samej Huge nie da się wypisać jako liczby całkowitej, bo przekazanie jej do fmt.Println konwertuje ją na int, a kompilator to wyłapuje (float64(Huge) działa, bo float pomieści taką wielkość):

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

Ta sama kontrola zatrzymuje w czasie kompilacji mniejsze pomyłki, jak var b byte = 300:

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

Stałe typowane

Nadaj stałej typ, a wszędzie zachowa się jak wartość tego typu, łącznie z tym, że Go odmówi mieszania typów:

const Limit int = 10

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

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

Z const Limit = 10 (beztypową) Limit * f się kompiluje i daje 20. Dlatego zostawiaj stałe beztypowe, chyba że typ niesie znaczenie. Niesie je wtedy, gdy deklarujesz stałe własnego nazwanego typu, bo tak Go buduje enumy:

type Weekday int

const (
	Sunday Weekday = iota
	Monday
	Tuesday
)

Tutaj typ jest sednem: funkcja przyjmująca Weekday dokumentuje, czego oczekuje. iota i oparte na nim wzorce enumów opisuje strona o enumach i iota.

const a var

Używaj const do wszystkiego, co jest naprawdę stałe: limitów, rozmiarów, nazw, kodów protokołów, formatów tekstu. Kontrolę przepełnienia w czasie kompilacji i dokładną arytmetykę dostajesz za darmo.

Pułapki

Stałe typowane się nie dopasowują. const Timeout int = 5 nie przekażesz tam, gdzie oczekiwany jest time.Duration, bez konwersji; beztypową const Timeout = 5 można pomnożyć: Timeout * time.Second.

Na stałych całkowitych dzielenie jest całkowite. const Half = 1 / 2 to 0, bo oba argumenty są beztypowymi liczbami całkowitymi. Napisz 1.0 / 2, żeby dostać 0.5.

Brak adresu. &MaxRetries się nie kompiluje. Jeśli API chce *int, najpierw skopiuj stałą do zmiennej.