Константы в Go

Константы в Go безопасны по типу и оптимизированы для компилятора, а также имеют следующие нововведения:
- Они поддерживают не типизированные константы
- Поддерживают неявное автоматическое преобразование
- Их можно использовать для реализации перечислений
Встроенная постоянная поддержка
Go поддерживает постоянную (константу) изначально. Константы в Go создаются во время компиляции исходного кода. Это означает, что значение элемента может быть инициализировано как переменная, но его выражение должно быть вычислено во время компиляции. Более того, после объявления и инициализации константы Go ее значение остается неизменным на протяжении всего времени существования программы.
Давайте посмотрим на один пример определения константы:
const Pi float64 = 3.14159265358979323846
const (
size int64 = 2048
i, j, s = 13, 14, "bar"
)
Однако типы констант Go ограничены базовыми типами данных Go, включая числовые, строковые и логические типы.
Не типизированные константы
Go предъявляет строгие требования к безопасности типов: даже если два типа имеют один и тот же базовый тип, они все равно являются разными типами данных и не могут сравниваться друг с другом. Это требование применяется не только к переменным, но и к типизированным константам. Вы можете увидеть это в следующем коде:
type myInt int
const n myInt = 13
const m int = n + 5 // Error:cannot use n + 5 (type myInt) as type int in const initializer
func main() {
var a int = 5
fmt.Println(a + n) // Error: invalid operation: a + n (mismatched types int and myInt)
}
Мы можем использовать явное преобразование, чтобы код работал правильно:
type myInt int
const n myInt = 13
const m int = int(n) + 5
func main() {
var a int = 5
fmt.Println(a + int(n))
}
Или мы можем использовать не типизированную константу:
type myInt int
const n = 13 // Untyped constant
func main() {
var a myInt = 5
fmt.Println(a + n)
}
Неявное преобразование
Неявное преобразование означает, что для не типизированных констант, участвующих в оценке выражения, компилятор Go автоматически преобразует не типизированную константу в соответствующий тип на основе информации о типе в контексте, а затем участвует в вычислении оценки. Это преобразование выполняется неявно.
Однако, поскольку объект преобразования является константой, это не вызывает проблем с типовой безопасностью. Компилятор Go обеспечит безопасность этого преобразования. Пример является следующий код:
type myInt int
const n = 13 // Untyped constant
func main() {
var a myInt = 5
fmt.Println(a + n)
}
Компилятор Go автоматически преобразует n
в myInt
тип.
Перечисления
Go не имеет собственного типа перечисления, но его можно достичь с помощью определения const
. В начале разработки Go оригинальные дизайнеры Go хотели объединить тип перечисления и константу в одно, чтобы не было необходимости предоставлять их по отдельности.
С
интаксис const
в Go предоставляет механизм для «неявного повторения предыдущего непустого выражения», например, следующий код
const (
Apple, Banana = 11, 22
Strawberry, Grape = 11, 22 // Repeating previous non-empty expression
Pear, Watermelon = 11, 22 // Repeating previous non-empty expression
)
itoa
в Go также упрощает объявление последовательно растущих числовых констант, например:
// $GOROOT/src/syscall/net_js.go
const (
_ = iota
IPV6_V6ONLY // 1
SOMAXCONN // 2
SO_ERROR // 3
)
Если есть разные перечисления, определенные несколькими блоками константного кода в исходном файле Go, itoa
в каждом блоке константного кода также изменяется независимо, то есть каждый блок константного кода имеет свою собственную itoa
, например следующий код:
const (
a = iota + 1 // 1, iota = 0
b // 2, iota = 1
c // 3, iota = 2
)
const (
i = iota << 1 // 0, iota = 0
j // 2, iota = 1
k // 4, iota = 2
)
Вывод
Константа в Go – это элемент синтаксиса, созданный во время компиляции исходного кода, и ее значение остается неизменным в течение жизни программы. Все вычисления постоянной оценки выполняются во время компиляции, а не во время выполнения, что может сократить время выполнения и облегчить компилятору выполнение оптимизации компиляции .
Кроме того, когда переменная является константным выражением, во время компиляции также могут быть обнаружены некоторые ошибки во время выполнения, такие как целочисленное деление на ноль, выход строкового индекса за пределы и т. д.