Основы констант в Go

Введение

В предыдущих уроках мы узнали о переменных в Go. В этом уроке мы рассмотрим концепцию констант, узнаем, как их использовать и почему они важны. Погрузимся в мир констант.

Точки знания:

• Что такое константы
• Объявление констант
• Генератор констант iota
• Использование констант

Skills Graph

Что такое константы?

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

Объявления констант могут иметь конкретные значения, присвоенные им. Их синтаксис похож на синтаксис переменных, но как только значение константы объявлено, оно не может быть изменено.

Константы полезны, когда вы хотите объявить значение, которое не должно изменяться, например, адрес веб - сайта или какое - то конкретное значащее значение, такое как π.

Объявление констант

Объявление констант похоже на объявление переменных. Ключевое слово var заменяется на ключевое слово const.

Примечание: Константам необходимо присвоить значение при объявлении.

В Go все переменные должны быть использованы после определения, но константы являются исключением. Даже если они не используются, ошибки не будет.

Синтаксис объявления константы выглядит следующим образом:

const name [type] = value

name - это имя объявляемой константы. type - это тип данных константы, но его можно опустить, так как Go может автоматически его вывести. Значение в конце - это значение, присвоенное константе.

Обратите внимание, что для объявления констант можно использовать только следующие типы:

• Целочисленные типы
• Числа с плавающей точкой
• Комплексные типы
• Логические типы
• Строковые типы

Давайте рассмотрим пример. Создайте новый файл с именем const.go в директории ~/project:

touch ~/project/const.go

Введите следующий код в файл const.go:

package main

import "fmt"

// Declare a single constant
const labex string = "LabEx" // explicitly specify the type as string
const labs = "LABS"    // automatically inferred as string by the compiler

// Declare multiple constants
const (
    hangzhou, chengdu = "HANGZHOU", "CHENGDU"
    monday, tuesday, wednesday = "MONDAY", "TUESDAY", "WEDNESDAY"
)

func main() {
    fmt.Printf("The type of labex is: %T, and its value is %s\n", labex, labex)
    fmt.Printf("The type of labs is: %T, and its value is %s\n", labs, labs)

    fmt.Println()

    fmt.Println(hangzhou, chengdu)
    fmt.Println(monday, tuesday, wednesday)
}

go run ~/project/const.go

После запуска программы вывод будет следующим:

The type of labex is: string, and its value is LabEx
The type of labs is: string, and its value is LABS

HANGZHOU CHENGDU
MONDAY TUESDAY WEDNESDAY

Здесь мы демонстрируем объявление одиночных и множественных констант. При объявлении множественных констант рекомендуется использовать скобки.

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

При объявлении множественных констант с использованием скобок если константа не инициализирована, она унаследует значение предыдущей константы.

Введите следующий код в файл const.go:

package main

import "fmt"

const (
    monday    = "MONDAY"
    tuesday   = "TUESDAY"
    wednesday = "WEDNESDAY"
    thursday
    friday
)

func main() {
    fmt.Println(monday, tuesday, wednesday, thursday, friday)
}

go run ~/project/const.go

Вывод будет следующим:

MONDAY TUESDAY WEDNESDAY WEDNESDAY WEDNESDAY

Здесь thursday и friday не имеют явных значений. Согласно правилам Go, когда константа не явно инициализирована, она унаследует значение предыдущей константы. В этом случае:

• thursday наследует значение wednesday.
• friday также наследует значение wednesday.

Такое поведение позволяет писать более компактный код, но может привести к неожиданным результатам, если вы не знаете об этом.

Если вы хотите, чтобы thursday и friday имели разные значения, вам нужно явно их присвоить:

const (
    monday    = "MONDAY"
    tuesday   = "TUESDAY"
    wednesday = "WEDNESDAY"
    thursday  = "THURSDAY"
    friday    = "FRIDAY"
)

Это даст ожидаемый вывод:

MONDAY TUESDAY WEDNESDAY THURSDAY FRIDAY

Генератор констант iota

В дополнение к объявлению констант по отдельности, мы также можем использовать iota для их пакетного объявления. Давайте рассмотрим пример. Напишите следующий код в файле const.go:

package main

import "fmt"

const (
    monday    = iota // initial value is 0
    tuesday   = iota // increments by 1 each time
    wednesday = iota
    thursday  = iota
    friday    = iota
)

func main() {
    fmt.Println(monday, tuesday, wednesday, thursday, friday)
}

go run ~/project/const.go

Вывод будет следующим:

0 1 2 3 4

При использовании iota начальное значение равно 0, и оно увеличивается на 1 для каждого последующего элемента.

После объявления первого элемента последующие константы не требуют присвоения с использованием iota. Следующий код также будет работать корректно:

package main

import "fmt"

const (
    monday    = iota // 0
    tuesday          // 1
    wednesday        // 2
    thursday         // 3
    friday           // 4
)

func main() {
    fmt.Println(monday, tuesday, wednesday, thursday, friday)
}

Что делать, если мы хотим пропустить определенное значение? В этом случае мы можем использовать подчеркивание. Следующий код пропускает константу для среды:

package main

import "fmt"

const (
    monday  = iota // 0
    tuesday        // 1
    _
    thursday // 3
    friday   // 4
)

func main() {
    fmt.Println(monday, tuesday, thursday, friday)
}

go run ~/project/const.go

Как вы можете видеть, вывод будет следующим:

0 1 3 4

Оператор iota также может быть использован для арифметических операций. Введите следующий код в файл const.go:

package main

import "fmt"

const (
    a = iota     // 0
    b = iota * 3 // 1 * 3
    c = iota + 4 // 2 + 4
)

const (
    B  = 1 << (iota * 10) // equals 1 << (0 * 10)
    KB                    // 1024
    MB                    // 1048576
)

func main() {
    fmt.Println(a, b, c)
    fmt.Println(B, KB, MB)
}

go run ~/project/const.go

Вывод будет следующим:

0 3 6
1 1024 1048576

В первой группе объявлений констант мы используем iota для выполнения простых арифметических операций.

Во второй группе мы используем iota с оператором сдвига влево << для выражения значений 1 КБ и 1 МБ в байтах. Например, 1 КБ равно 1024 байтам, а 1 МБ равно 1024 * 1024, то есть 1048576 байтам.

Вопрос для самопроверки

Теперь давайте закрепим то, что мы узнали. Создайте новый файл с именем iota.go и используйте iota и константы для вывода значений 1 ГБ и 1 ТБ в байтах.

Требования:

1. Не выводите напрямую преобразованные числа. Используйте iota для преобразования.
2. Файл iota.go должен находиться в директории ~/project.

Подсказка: Вы можете обратиться к коду в разделе "iota".

Требуемый формат вывода следующий:

1GB is equal to 1073741824B
1TB is equal to 1099511627776B

Итоги

Давайте обобщим то, что мы узнали в этом уроке:

• Константы не могут быть изменены после объявления.
• Константы можно объявлять с использованием ключевого слова const.
• При объявлении нескольких констант предпочтительно использовать скобки.
• Генератор констант iota можно использовать для перечислительных объявлений.
• iota также может быть использован в арифметических операциях.

В этом уроке мы изучили константы и также познакомились с генератором констант iota. Строки, целые числа, числа с плавающей точкой и константы - это основные типы данных в Go.