🦫 Самоучитель по Go для начинающих. Часть 4. Переменные. Типы данных и их преобразования. Основные операторы

Переменные

Что такое переменная

Переменные – это именованные места в памяти, предназначенные для временного или постоянного хранения значений.

Использование переменных в программировании позволяет:

1. Хранить данные. Переменные прендназначены для хранения значений, что позволяет запоминать информацию и использовать её в разных частях кода.
2. Обрабатывать данные. Значения переменных могут изменяться в процессе написания программы, что обеспечивает гибкость при работе с данными.

Способы задания переменных в Go

В Go есть несколько способов задания переменных:

1. С помощью ключевого слова var с указанием имени переменной:

        var num1 int // инициализировали переменную num1 с нулевым значением
num1 = 1 // явно присвоили переменной num1 значение 1
var num2 int = 2 // явно присвоили переменной num2 значение 2
var num3 = 3 // явно присвоили переменной num3 значение 3

    

1. Краткое объявление с помощью оператора присваивания :=, который сам распознает тип данных в зависимости от значения:

        num := 1 // переменная num типа int
str := "abcd" // переменная num типа string
    

1. Множественное присваивание значений с помощью ключевого слова var или оператора :=

        var a, b int
var num1, num2 int = 1, 2
var num3, num4 = 3, 4
var (
	num5 int = 5
	num6 int = 6
)

num7, str := 7, "string"

    

В Go по умолчанию переменные инициализируются своим нулевым значением. Для целых чисел это будет 0, для строк – пустая строка (""), для логических значений – false и так далее.

Константы

Константы – это величины с неизменяемым значением, предназначенные для хранения фиксированных данных. Их вычисление происходит во время компиляции программы. В Go для создания констант используется ключевое слово const:

        const pi = 3.1415926
pi = 3 // ошибка

const e float64 = 2.71828

    

Вывод значения и типа переменной

Для вывода значения и типа переменной нужно передать её как аргумент в функции fmt.Print (или fmt.Println для перевода на новую строку) и fmt.Printf соответственно из ранее изученного нами пакета fmt:

        num := 100
fmt.Print(num) // 100
fmt.Printf("%T", num) // int

    

1. Функция fmt.Printf форматирует вывод в соответствии с шаблоном. В нашем примере вместо %T на вывод поступит тип переменной num.

Правила именования переменных в Go

Стоит помнить, что имена переменных в Go:

1. Могут содержать только латинские буквы, цифры и символ подчеркивания (a-z, A-Z, 0-9, и _ ).
2. Должны начинаться с буквы или символа подчеркивания.
3. Чувствительны к регистру. То есть name, NAME и Name – это три разные переменные.
4. Не могут являться ключевыми словами, определенными в Go: var, break, const, type и так далее. Полный список недопустимых имён можно найти в спецификации Go.

Помимо правил рекомендуется следовать следующим соглашениям по именованию переменных:

1. По возможности используйте короткие имена, особенно для локальных переменных и итераторов в цикле, если это не приводит к потере смысла. Пример: cnt вместо countValues, i вместо index и так далее.
2. Чем дальше от своего объявления находится имя, тем более описательным оно должно быть. Также это касается глобальных и уникальных переменных.
3. Для экспортируемых переменных (которые видны вне текущего пакета) используйте заглавные буквы. Пример: GetUser, GenerateValue.

Типы данных

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

Типы данных в Go делятся на две категории: базовые и составные. К первым относятся целые, вещественные и комплексные числа, строки, байты и руны. К составным типам данных относятся массивы, структуры, срезы, мапы, каналы, указатели, функции и интерфейсы.

В этом уроке мы рассмотрим базовые типы данных, а с составными познакомимся в следующих статьях.

Базовые типы данных

Целые числа – int

Целые числа в Go представлены 10 типами данных, выбор которых зависит от необходимого диапазона значений. Выделяют две группы чисел: знаковые (int) и беззнаковые (uint). Первые из них могут быть отрицательными и за счет этого обладают меньшим диапазоном значений, в то время как вторые – только положительные и с большим диапазоном.

Каждый из целочисленных типов бывает 1-, 2-, 4- и 8-байтным и записывается как int8, int16, int32, int64 соответственно (для uint аналогично). Количество бит определяет диапазон значений. Например, для int8 – от -128 до 127, int16 от -32768 до 32767 и так далее.

• int — тип по умолчанию для целого числа. Если при инициализации переменной вы не укажете тип, он по умолчанию будет int.
• Объявление:

        var num1 int = 1 // целое число
var num2 uint = 2 // целое беззнаковое число
var num3 int8 = 3 // целое число разрядностью 1 байт

    

Вещественные числа – float

Дробные числа в Go представлены типом float, который может быть 32- и 64-битным. Формат его представления регулируются стандаром IEEE754.

• float64 — тип по умолчанию для вещественного числа. Если при инициализации переменной вы не укажете тип, он по умолчанию будет float64.
• Объявление:

        var num1 float32
var num2 float64 = 4.5
c := 1.2 // float64

    

• Максимальные и минимальные значения для типа float можно узнать с помощью функций math.MaxFloat64 и math.SmallestNonzeroFloat64 (для 32-битных нужно изменить 64 на 32) соответственно.

        fmt.Printf("%.50e\\\\n", math.MaxFloat64)

    

Комплексные числа – complex

Комплексные числа в Go определяются двумя типами с разной разрядностью – compex64 и complex128, которые содержат действительные и мнимые части, принадлежащие типам float32 и float64 соответственно. Они часто используются в научных целях, но в реальной разработке встречаются редко.

• Объявление:

        // 1 способ
var num1 complex64
var num2 complex128
num3 := 1 + 2i

// 2 способ
var num 4 = complex(1.2, 3.4) // 1.2 + 3.4i

    

Логические значения – bool

Тип данных bool может иметь одно из двух логических значений – true (истина) или false (ложь). Он часто используется в условных операторах и логических выражениях.

• Объявление:

        var a bool
b := true
c := false


    

Строки – string

Строки в Go представляют собой неизменяемую последовательность байтов. Каждый символ в них может занимать разное количество байтов в зависимости от используемой кодировки.

• Объявление:

        var a string
b := "строка"


    

Руны – rune

Тип данных rune в Go является псевдонимом для int32 и используется для представления Unicode символов.

• Для знакомства с Unicode рекомендуем прочитать статью "Символы Unicode: о чём должен знать каждый разработчик"
• Объявление:

        var a rune
b := []rune("abc")

// вывод на экран
fmt.Println(a, b) // 0 [97 98 99]


    

Байты – byte

Тип данных byte в Go – это псевдоним для беззнакового 8-битного целочисленного типа (uint8). Он может принимать значения от 0 до 255, поэтому используется для представления ASCII-символов.

• Объявление:

        var a byte
b := []byte("abc")

// вывод на экран
fmt.Println(a, b) // 0 [97 98 99]

    

Операторы

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

Рассмотрим классификацию операторов по пяти группам: арифметические, логические, сравнения, битовые и остальные.

Арифметические операторы

Логические операторы

Операторы сравнения

Битовые операторы

Остальные операторы

Конвертация типов данных

Конвертация числовых типов

Перевод между целыми числами разными разрядности осуществляется следующим образом:

        var smallNum int8 = 2
var bigNum = int64(smallNum) // 2
    

Стоит учитывать, что преобразование из большего по разрядности типа данных в меньший может привести к переполнению:

        var bigNum int64 = 130
var smallNum = int8(bigNum) // -126
    

Конвертация целых чисел в дробные и наоборот

Так можно преобразовать тип int в float:

        var intNum int = 63
var floatNum = float64(intNum) // 63
    

При переводе дробных чисел в целые происходит отбрасывание дробной части:

        var floatNum2 = 12.34
var intNum2 = int(floatNum2) // 12
    

Следует помнить о переполнении и при необходимости увеличивать разрядность типа:

        var floatNum float64 = 32768
var intNumBad = int16(floatNum) // -32768
var intNumGood = int64(floatNum) // 32768
    

Конвертация чисел в строки

Для перевода числовых типов (int, float) в строку применяются функции fmt.Sprint и fmt.Sprintf из стандартного пакета fmt. Обе они возвращают строку, но отличаются тем, что первая форматирует аргументы с использованием стандартого формата, а вторая – в соответствии с передаваемым шаблоном.

        intToString := fmt.Sprintf("%d", 12) // шаблон %d означает целое число в десятичной системе счисления
floatToString := fmt.Sprint(34.56) // "34.56"
    

У шаблонов есть множество вариантов применения. Например, так можно без использования дополнительных функций перевести число в восьмеричную систему счисления:

        decToOct := fmt.Sprintf("%o", 1234) // 2322
    

Полный список шаблонов можно найти в официальной документации go.

Альтернативный способ перевести целое число в строку – воспользоваться функцией strconv.Itoaиз стандартного пакета strconv:

        s := strconv.Itoa(1234) // "1234"
    

Конвертация строк в числа

Для конвертации строк в числа используется функция strconv.Atoi , которая возвращает два значения – результат и ошибку. Для обработки ошибок в Go используется специальная конструкция:

        num, err := strconv.Atoi("1234") // конвертация строки в число

// обработка ошибки
if err != nil {
	fmt.Println(err)
}
fmt.Println(num) // 1234
    

Если вместо числа передать другие символы, то возникнет ошибка, а переменной num присвоится 0:

        num, err := strconv.Atoi("строка") // конвертация строки в число

// обработка ошибки
if err != nil {
	fmt.Println(err) // strconv.Atoi: parsing "строка": invalid syntax
}
fmt.Println(num) // 0
    

Подведём итоги

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

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

Содержание самоучителя

1. Особенности и сфера применения Go, установка, настройка
2. Ресурсы для изучения Go с нуля
3. Организация кода. Пакеты, импорты, модули. Ввод-вывод текста.
4. Переменные. Типы данных и их преобразования. Основные операторы
5. Условные конструкции if-else и switch-case. Цикл for. Вложенные и бесконечные циклы
6. Функции и аргументы. Области видимости. Рекурсия. Defer
7. Массивы и слайсы. Append и сopy. Пакет slices
8. Строки, руны, байты. Пакет strings. Хеш-таблица (map)
9. Структуры и методы. Интерфейсы. Указатели. Основы ООП
10. Наследование, абстракция, полиморфизм, инкапсуляция
11. Обработка ошибок. Паника. Восстановление. Логирование
12. Обобщенное программирование. Дженерики
13. Работа с датой и временем. Пакет time
14. Интерфейсы ввода-вывода. Буферизация. Работа с файлами. Пакеты io, bufio, os
15. Конкурентность. Горутины. Каналы
16. Тестирование кода и его виды. Table-driven подход. Параллельные тесты
17. Основы сетевого программирования. Стек TCP/IP. Сокеты. Пакет net