14 декабря 2023

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

Энтузиаст-разработчик, автор статей по программированию. Сфера интересов - backend, web 3.0, кибербезопасность.
В этом уроке мы изучим фундаментальные понятия в программировании: переменные, типы данных и операторы, а также научимся преобразовывать один тип данных в другой.
🏃 Самоучитель по Go для начинающих. Часть 4. Переменные. Типы данных и их преобразования. Основные операторы

Переменные

Переменные в Go
Переменные в Go

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

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

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

  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 разработчика
Больше полезных материалов вы найдете на нашем телеграм-канале «Библиотека Go разработчика»
🎓 Библиотека Go для собеса
Подтянуть свои знания по Go вы можете на нашем телеграм-канале «Библиотека Go для собеса»
🧩 Библиотека задач по Go
Интересные задачи по Go для практики можно найти на нашем телеграм-канале «Библиотека задач по Go»

Константы

Константы – это величины с неизменяемым значением, предназначенные для хранения фиксированных данных. Их вычисление происходит во время компиляции программы. В 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
Типы данных в Go

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

Типы данных в 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 символов.

        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]

    

Операторы

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

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

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

Оператор Описание Пример Результат
+ сложение 12 + 4 16
- вычитание 10 – 6 4
* умножение 3 * 4 12
/ деление 4 / 2 2
% взятие остатка 5 % 3 2

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

Оператор Описание Пример Результат
&& логическое И 1 > 2 && 3 < 4 false
|| логическое ИЛИ 2 < 3 || 4 > 5 true
! логическое НЕ !(2 < 3) false

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

Оператор Описание Пример Результат
== равно 1 == 1 true
!= не равно 2 != 3 true
< меньше 4 < 3 false
<= меньше или равно 5 <= 5 true
> больше 6 > 7 false
>= больше или равно 10 >= 9 true

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

Оператор Описание Пример Результат
& побитовое И 10 (1010) & 8 (1000) 8 (1000)
| побитовое ИЛИ 10 (1010) | 8 (1000) 10 (1010)
^ исключающее ИЛИ (XOR) 10 (1010) ^ 8 (1000) 2 (0010)
<< битовый сдвиг влево 2 (0010) << 2 8 (1000)
>> битовый сдвиг вправо 8 (1000) >> 2 2 (0010)

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

Оператор Описание Пример Результат
& взятие адреса b := &a переменная b хранит адрес переменной a
* указатель на тип или переменную *b = 5 эквивалентно записи a = 5
<- получение и отправка значений val := <-channel получение значения из канала channel

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

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

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

        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

МЕРОПРИЯТИЯ

Комментарии

ВАКАНСИИ

Добавить вакансию

ЛУЧШИЕ СТАТЬИ ПО ТЕМЕ