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

Кроме того, когда переменная является константным выражением, во время компиляции также могут быть обнаружены некоторые ошибки во время выполнения, такие как целочисленное деление на ноль, выход строкового индекса за пределы и т. д.