Константы в Golang: const, типизированные и нетипизированные

Константа это значение, зафиксированное на этапе компиляции. Объявите её через const, и Go отвергнет любую попытку её изменить.

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

Константы можно объявлять на уровне пакета или внутри функции, по одной на строку или группой в блоке const ( ... ). MB и GB вычисляются из других констант, и компилятор выполняет эту арифметику один раз, при сборке.

Присваивание константе, например MaxRetries = 5, это ошибка компиляции:

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

Что может быть константой

Только три вида значений: булевы, числа (целые, с плавающей точкой, комплексные и руны) и строки. Значение должен уметь вычислить компилятор: литералы, другие константы, арифметика над ними и несколько встроенных функций вроде len от константной строки.

Всё, что требует выполнения кода или выделения памяти, исключено:

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

Почему в Go нет константных слайсов и мап

Слайсы, мапы и содержащие их структуры это ссылки на память, которая существует во время выполнения, поэтому компилятор не может вшить их в программу как фиксированные значения, а модификаторов readonly или final для переменных в Go нет. Типичные обходные пути:

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

Копия стоит одной аллокации на вызов, и для данных размером с конфигурацию это нормально. Для поиска по ключу есть ещё один вариант, похожий на константу: switch внутри функции, func statusText(code int) string { switch code { ... } }.

Нетипизированные константы

Константа, объявленная без типа, называется нетипизированной. У неё есть вид (целое, число с плавающей точкой, руна, строка, bool), но нет конкретного типа Go, пока она не использована, и она подстраивается под контекст:

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 работает как int, float64, uint8 и float32 без всякого преобразования. Поэтому и компилируется time.Sleep(2 * time.Second): 2 нетипизирована и становится time.Duration.

Когда контекст не требует типа, как в x := Ratio, константа получает тип по умолчанию:

Точная арифметика

Нетипизированные числовые константы точны. Компилятор представляет целые числа как минимум 256 битами, поэтому промежуточные значения могут быть намного больше любого типа 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
}

Саму Huge нельзя напечатать как целое число: при передаче в fmt.Println она преобразуется в int, и компилятор это ловит (float64(Huge) работает, потому что float вмещает такую величину):

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

Та же проверка на этапе компиляции останавливает и ошибки поменьше, например var b byte = 300:

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

Типизированные константы

Дайте константе тип, и она везде ведёт себя как значение этого типа, включая отказ Go смешивать типы:

const Limit int = 10

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

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

С const Limit = 10 (нетипизированной) выражение Limit * f компилируется и даёт 20. Поэтому оставляйте константы нетипизированными, если тип не несёт смысла. Смысл он несёт, когда вы объявляете константы собственного именованного типа; так в Go строятся перечисления:

type Weekday int

const (
	Sunday Weekday = iota
	Monday
	Tuesday
)

Здесь тип и есть суть: функция, принимающая Weekday, сама документирует, что ей нужно. iota и шаблоны перечислений на его основе разобраны на странице про enum и iota.

const и var

Используйте const для всего, что действительно фиксировано: лимиты, размеры, имена, коды протоколов, строки формата. Проверки переполнения на этапе компиляции и точная арифметика достаются бесплатно.

Подводные камни

Типизированные константы не подстраиваются. const Timeout int = 5 нельзя передать туда, где ожидается time.Duration, без преобразования; нетипизированную const Timeout = 5 можно умножить: Timeout * time.Second.

Деление целочисленных констант целочисленное. const Half = 1 / 2 равна 0, потому что оба операнда нетипизированные целые. Напишите 1.0 / 2, чтобы получить 0.5.

Нет адреса. &MaxRetries не компилируется. Если API нужен *int, сначала скопируйте константу в переменную.