Golang const: typisierte und untypisierte Konstanten erklärt

Eine Konstante ist ein Wert, der zur Compilezeit feststeht. Du deklarierst sie mit const, und Go verweigert jeden Versuch, sie zu ändern.

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

Konstanten können auf Paketebene oder in einer Funktion deklariert werden, eine pro Zeile oder gruppiert in einem Block const ( ... ). MB und GB werden aus anderen Konstanten berechnet, und der Compiler erledigt diese Rechnung einmal beim Build.

Eine Zuweisung an eine Konstante, etwa MaxRetries = 5, ist ein Compilerfehler:

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

Was eine Konstante sein kann

Nur drei Arten von Werten: Booleans, Zahlen (Ganzzahlen, Floats, komplexe Zahlen und Runes) und Strings. Der Compiler muss den Wert berechnen können, also Literale, andere Konstanten, Arithmetik darauf und ein paar eingebaute Funktionen wie len eines konstanten Strings.

Alles, was Code ausführen oder Speicher anlegen muss, fällt raus:

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

Warum Go keine konstanten Slices oder Maps hat

Slices, Maps und Structs, die sie enthalten, sind Verweise auf Speicher, der zur Laufzeit existiert. Der Compiler kann sie also nicht als feste Werte ins Programm einbacken, und Go hat keine Modifikatoren wie readonly oder final für Variablen. Die üblichen Workarounds:

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

Die Kopie kostet pro Aufruf eine Allokation, was für Daten in Konfigurationsgröße in Ordnung ist. Für Lookups per Schlüssel ist ein switch in einer Funktion eine weitere konstantenähnliche Option: func statusText(code int) string { switch code { ... } }.

Untypisierte Konstanten

Eine Konstante, die ohne Typ deklariert ist, ist untypisiert. Sie hat eine Art (Ganzzahl, Float, Rune, String, bool), aber keinen bestimmten Go-Typ, bis sie verwendet wird, und passt sich an den Kontext an:

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 funktioniert ohne Konvertierung als int, float64, uint8 und float32. Deshalb kompiliert time.Sleep(2 * time.Second): 2 ist untypisiert und wird zu einer time.Duration.

Verlangt der Kontext keinen Typ, wie bei x := Ratio, bekommt die Konstante ihren Standardtyp:

Exakte Arithmetik

Untypisierte numerische Konstanten sind exakt. Der Compiler stellt Ganzzahlen mit mindestens 256 Bit dar, also dürfen Zwischenwerte weit größer sein als jeder Go-Typ:

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 selbst lässt sich nicht als Ganzzahl ausgeben, weil die Übergabe an fmt.Println sie in ein int konvertiert, und das fängt der Compiler ab (float64(Huge) funktioniert, da ein Float diese Größenordnung fassen kann):

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

Dieselbe Prüfung stoppt kleinere Fehler zur Compilezeit, etwa var b byte = 300:

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

Typisierte Konstanten

Gibst du einer Konstanten einen Typ, verhält sie sich überall wie ein Wert dieses Typs, einschließlich der Weigerung von Go, Typen zu mischen:

const Limit int = 10

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

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

Mit const Limit = 10 (untypisiert) kompiliert Limit * f und ergibt 20. Lass Konstanten also untypisiert, außer der Typ trägt Bedeutung. Das tut er, wenn du Konstanten eines eigenen benannten Typs deklarierst, und so baut Go Enums:

type Weekday int

const (
	Sunday Weekday = iota
	Monday
	Tuesday
)

Hier ist der Typ der Punkt: Eine Funktion, die ein Weekday nimmt, dokumentiert, was sie will. iota und die darauf aufbauenden Enum-Muster behandelt die Seite zu Enums und iota.

const vs var

Nimm const für alles, was wirklich feststeht: Limits, Größen, Namen, Protokollcodes, Format-Strings. Overflow-Prüfungen zur Compilezeit und exakte Arithmetik bekommst du gratis dazu.

Stolperfallen

Typisierte Konstanten passen sich nicht an. const Timeout int = 5 kann ohne Konvertierung nicht übergeben werden, wo eine time.Duration erwartet wird; ein untypisiertes const Timeout = 5 lässt sich multiplizieren: Timeout * time.Second.

Ganzzahldivision bei ganzzahligen Konstanten. const Half = 1 / 2 ist 0, weil beide Operanden untypisierte Ganzzahlen sind. Schreib 1.0 / 2, um 0.5 zu bekommen.

Keine Adresse. &MaxRetries kompiliert nicht. Will eine API ein *int, kopier die Konstante vorher in eine Variable.