Основы программирования на Go: от первой строки кода до сложных структур данных

Введение в мир Go: установка инструментов и настройка рабочего пространства

Представьте, что вы решили построить современный скоростной катер. Вам нужен материал, который будет легким, как алюминий, но прочным, как сталь, и двигатель, который заводится мгновенно. В мире программирования таким материалом стал язык Go (или Golang). Созданный в недрах Google инженерами, которые устали ждать, пока их огромные программы скомпилируются, Go объединил в себе простоту Python и мощь C++. Сегодня на нем работают серверы YouTube, облака Google, инфраструктура Uber и системы мониторинга по всему миру.

Почему именно Go?

Прежде чем мы возьмем в руки инструменты, важно понять философию этого языка. Программирование часто страдает от избыточной сложности. В некоторых языках существует десять способов сделать одно и то же действие, и разработчики тратят часы на споры о том, какой из них «красивее». Go идет другим путем: в нем почти всегда есть только один очевидный и правильный способ решения задачи.

Ключевые преимущества Go, которые делают его идеальным для старта:

Скорость компиляции. Вы нажимаете кнопку «Запуск», и программа готова через доли секунды. Это критично для обучения, когда вы постоянно пробуете новые идеи.

Статическая типизация. Это звучит сложно, но на деле это «защита от дурака». Язык заставляет вас четко определять, где у вас числа, а где текст, что предотвращает 80% глупых ошибок еще до запуска программы.

Минимализм. В Go всего 25 ключевых слов. Для сравнения, в C++ их около сотни, а в Java — более пятидесяти. Вы выучите основы синтаксиса за пару вечеров.

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

Подготовка фундамента: Установка Go

Чтобы компьютер понимал ваш код, ему нужен компилятор — специальная программа, которая переводит человекочитаемый текст на Go в понятные процессору нули и единицы.

Шаг 1: Загрузка дистрибутива

Перейдите на официальный сайт go.dev. Вы увидите список файлов для разных операционных систем.

* Windows: Скачивайте файл с расширением .msi. Это привычный установщик. * macOS: Выбирайте .pkg. Обратите внимание на архитектуру: если у вас процессор Apple Silicon (M1, M2, M3), берите версию arm64, если старый Intel — amd64. * Linux: Обычно это архив .tar.gz, который нужно распаковать в папку /usr/local/go.

Шаг 2: Процесс установки

На Windows и macOS просто следуйте инструкциям мастера установки. По умолчанию Go устанавливается в C:\Go (Windows) или /usr/local/go (macOS/Linux). Крайне важно не менять эти пути без веской причины, так как многие инструменты ожидают найти Go именно там.

Шаг 3: Проверка связи

После установки откройте терминал (Командная строка или PowerShell в Windows, Terminal в macOS). Введите команду:

Если вы видите сообщение вида go version go1.22.0 windows/amd64, значит, сердце вашей будущей системы установлено правильно. Если же система выдает ошибку «Команда не найдена», скорее всего, путь к Go не добавился в переменную окружения PATH. В современных установщиках это происходит автоматически, но иногда требуется перезагрузка компьютера.

Выбор рабочего места: VS Code против GoLand

Код можно писать хоть в «Блокноте», но это как пытаться собрать часы кухонным ножом. Нам нужна интегрированная среда разработки (IDE) — программа, которая будет подсвечивать ошибки, подсказывать названия функций и помогать в отладке.

Вариант А: Visual Studio Code (VS Code) — Легкость и гибкость

Это бесплатный редактор от Microsoft, который выбирает большинство новичков и профессионалов.

Скачайте и установите VS Code.

Откройте вкладку Extensions (иконка квадратиков слева или Ctrl+Shift+X).

Введите в поиске «Go» и установите официальный плагин от команды Google (автор: Go Team at Google).

Важный нюанс: После установки плагина VS Code предложит установить дополнительные инструменты (tools). Нажмите «Install All» в появившемся окне внизу справа. Эти маленькие утилиты научат редактор форматировать ваш код и находить в нем опечатки.

Вариант Б: JetBrains GoLand — Профессиональный комбайн

Это мощная платная IDE, созданная специально для Go. Для студентов и преподавателей у JetBrains есть бесплатные лицензии. GoLand «из коробки» умеет всё: от глубокого анализа кода до работы с базами данных. Если вы планируете заниматься программированием всерьез и имеете доступ к академической лицензии, это отличный выбор.

Анатомия рабочего пространства

В старых версиях Go (до 2018 года) разработчики были заперты в рамках одной папки GOPATH. Это было неудобно: все проекты должны были лежать в одном месте. Современный Go использует систему Go Modules. Теперь вы можете создать папку проекта в любом месте на диске — на рабочем столе, в «Документах» или в специальной папке для учебы.

Создаем первый проект

Давайте подготовим почву для вашей первой программы. Создайте на компьютере папку, например, learning-go. Внутри нее создайте еще одну папку hello-world.

Откройте терминал внутри папки hello-world. Теперь нам нужно инициализировать модуль. Модуль — это единица организации кода в Go. Выполните команду:

В папке появится файл go.mod. Если открыть его в текстовом редакторе, вы увидите нечто подобное:

Это «паспорт» вашего проекта. Здесь указано его имя и версия языка, которую вы используете. Когда в будущем вы начнете использовать чужой код (библиотеки), информация о них тоже попадет в этот файл.

Командный центр разработчика: Основные инструменты

Разработка на Go тесно связана с консолью. Вам не нужно запоминать сотни флагов, достаточно четырех основных команд, которые вы будете использовать 99% времени.

1. go run — Быстрый старт

Представьте, что вы написали код в файле main.go. Чтобы мгновенно увидеть результат его работы, вы пишете:

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

2. go build — Создание продукта

Когда ваша программа готова и вы хотите отдать ее другу (у которого, возможно, даже не установлен Go), вы используете:

Go создаст исполняемый файл (например, main.exe на Windows). Этот файл полностью автономен. В нем уже содержатся все необходимые библиотеки. Это одна из главных «фишек» Go — вы получаете один файл, который просто работает.

3. go fmt — Идеальный порядок

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

Автоматически переписывает ваш код, приводя его к общепринятому стандарту. Профессиональные разработчики настраивают свои редакторы так, чтобы go fmt запускался автоматически при каждом сохранении файла.

4. go mod tidy — Чистка зависимостей

Когда ваш проект разрастется и вы начнете добавлять или удалять сторонние пакеты, эта команда проверит ваш файл go.mod, скачает недостающее и удалит лишнее. Она поддерживает ваш проект в чистоте.

Нюансы настройки на разных ОС

Хотя Go кроссплатформенный, есть детали, которые могут сбить новичка с толку.

Windows и терминалы. В Windows есть три популярных терминала: классическая Командная строка (cmd), PowerShell и Git Bash. Мы рекомендуем использовать PowerShell или современный Windows Terminal. В них лучше работает автодополнение команд и корректно отображаются цвета.

macOS и права доступа. Иногда при установке инструментов через VS Code система может запросить пароль администратора. Это нормально — Go пытается установить вспомогательные утилиты в системные папки. Также на macOS важно иметь установленные инструменты разработчика Xcode (выполните xcode-select --install в терминале, если возникнут проблемы с компиляцией).

Linux и переменные окружения. Если вы устанавливаете Go вручную из архива, вам обязательно нужно добавить путь к бинарным файлам в ваш профиль (например, в файл .bashrc или .zshrc):

Без этой строки терминал будет «забывать», что такое команда go после каждой перезагрузки.

Почему ваша рабочая среда — это часть дисциплины

Многие новички пренебрегают настройкой окружения, пытаясь писать код в онлайн-редакторах. Но настоящая разработка начинается тогда, когда вы приручаете локальные инструменты. Умение работать с терминалом, понимать структуру папок проекта и настраивать IDE — это 30% навыков профессионального программиста.

Когда вы настроили VS Code, установили плагины и инициализировали свой первый модуль через go mod init, вы создали профессиональный фундамент. Теперь, если ваша программа ведет себя странно, вы будете уверены: проблема в логике кода, а не в том, что компьютер вас «не понимает».

В следующих главах мы начнем наполнять этот фундамент смыслом: научимся объявлять переменные, строить логические условия и циклы. Но прямо сейчас убедитесь, что команда go version выдает заветную строку, а файл go.mod гордо лежит в папке вашего проекта. Это ваш первый шаг в мир большого системного программирования.

Первая программа и основы управления проектом через модули и консольные команды

Представьте, что вы строите огромный склад. Чтобы работа не превратилась в хаос, вам недостаточно просто свалить стройматериалы в кучу — вам нужен четкий план, маркированные коробки и понимание того, как каждая деталь соединяется с другой. В мире Go написание кода начинается не со строчки fmt.Println, а с создания фундамента — структуры проекта. Если в других языках программирования вы могли просто создать текстовый файл и запустить его, то Go требует дисциплины с первой секунды. Эта дисциплина вознаграждается: ваши программы будут предсказуемыми, быстрыми и легкими в поддержке.

Анатомия файла main.go

Любая программа на Go начинается с точки входа. Это как главная дверь в здание: компьютер должен знать, с какого именно места начинать выполнение инструкций. В Go такой дверью является пакет main и функция main.

Рассмотрим классический пример, который мы разберем до мельчайших деталей:

Декларация пакета: package main

Первая строка package main — это не просто формальность. В Go весь код организован в пакеты. Пакет — это способ группировки связанных файлов. Однако слово main здесь магическое. Оно сообщает компилятору: «Этот файл не просто библиотека функций для других программ, это самостоятельное приложение, которое можно запустить».

Если вы назовете пакет иначе, например package calculator, компилятор соберет его как вспомогательный модуль, но вы не сможете запустить его как программу — у него не будет «входной двери».

Импорт инструментов: import "fmt"

Ключевое слово import позволяет нам использовать код, написанный другими людьми или разработчиками самого языка. В данном случае мы подключаем пакет fmt (сокращение от format). Этот пакет отвечает за ввод и вывод данных. Без него наша программа была бы «немой» — она могла бы производить вычисления внутри процессора, но мы бы никогда не увидели результат на экране.

> Важное правило Go, которое часто раздражает новичков: если вы импортировали пакет, но не использовали его, программа не скомпилируется. Go — это язык про чистоту. Лишний импорт — это лишний вес, и компилятор заставит вас его убрать.

Главная функция: func main()

func main() — это сердце программы. Именно отсюда начинается выполнение кода.

* func — ключевое слово для объявления функции. * main — зарезервированное имя. * () — здесь могут быть параметры, но у главной функции их нет. * {} — фигурные скобки определяют границы «тела» функции. Все, что находится внутри них, будет выполнено по порядку.

Управление проектом через Go Modules

В современных реалиях программирования ваш код редко живет в изоляции. Он зависит от версий компилятора, внешних библиотек и структуры папок. Для управления всем этим хаосом в Go существует система модулей.

Модуль в Go — это коллекция пакетов, которые выпускаются вместе. Файл go.mod — это паспорт вашего проекта. В нем записано имя проекта и версия Go, для которой он предназначен.

Инициализация проекта

Когда вы создаете новый проект, первым делом нужно выполнить команду:

go mod init <название_модуля>

Например: go mod init github.com/myuser/my-first-app

Почему название выглядит как ссылка? В экосистеме Go принято именовать модули в соответствии с путем к репозиторию, где они будут лежать. Это решает проблему уникальности: если два программиста назовут свои проекты test, система модулей поймет, чей именно код нужно скачать, ориентируясь на доменное имя (например, github.com или gitlab.com).

После выполнения команды в вашей папке появится файл go.mod. Если вы его откроете, то увидите нечто подобное:

Это гарантирует, что любой другой разработчик, скачав ваш код, будет знать, какая версия языка нужна для корректной работы.

Консольные команды: жизненный цикл разработки

| Команда | Описание | Когда использовать | | :--- | :--- | :--- | | go run | Компиляция во временную папку и запуск | Для быстрой проверки кода и тестов | | go build | Создание исполняемого бинарного файла | Для подготовки программы к релизу | | go fmt | Автоматическое форматирование кода | Перед каждым сохранением или коммитом | | go mod tidy | Очистка и обновление зависимостей | При добавлении новых библиотек |

Команда go run

go run main.go — это самый быстрый способ увидеть результат. Она делает две вещи одновременно: компилирует код во временную папку и тут же запускает его. После завершения программы временный файл удаляется.

Это идеально подходит для обучения и быстрых экспериментов. Однако важно понимать: go run — это не то, как программы работают в реальности. Это лишь «предпросмотр».

Команда go build

Когда ваша программа готова к выходу в свет, вы используете go build. Эта команда создает бинарный исполняемый файл.

В Windows это будет файл с расширением .exe.

В Linux и macOS — файл без расширения, но с флагом исполнения.

Прелесть Go в том, что этот файл — самодостаточен. Вам не нужно устанавливать Go на компьютер пользователя, чтобы запустить вашу программу. Вы можете просто отправить этот файл другу, и он заработает. Это называется «статической линковкой». Все необходимые библиотеки (включая fmt) уже упакованы внутрь этого файла.

Команда go fmt

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

> «Gofmt's style is no one's favorite, yet gofmt is everyone's favorite.» (Стиль gofmt никого не устраивает полностью, но при этом gofmt — любимый инструмент каждого). > > Rob Pike, один из создателей Go

Глубокое погружение: как Go видит ваш код

Чтобы понять, почему Go работает именно так, давайте разберем процесс превращения текста в работающую программу. Когда вы запускаете go build, происходит несколько этапов:

Лексический анализ: Компилятор читает ваш файл и разбивает его на «токены» (ключевые слова, идентификаторы, операторы).

Синтаксический анализ: Проверка того, правильно ли расставлены скобки и соблюдена ли логика языка.

Проверка типов: На этом этапе Go убеждается, что вы не пытаетесь сложить строку с числом или передать в функцию fmt.Println что-то недопустимое.

Генерация кода: Самый важный этап. Go переводит ваш высокоуровневый код в ассемблер, а затем в машинный код (нули и единицы), специфичный для вашего процессора (x86 или ARM).

Организация нескольких файлов в одном пакете

По мере роста проекта одного файла main.go станет мало. Вы захотите разбить код на логические части. В Go это работает иначе, чем в Java или C#. Если у вас есть папка myproject и в ней лежат два файла:

* main.go (с package main) * utils.go (тоже с package main)

То для Go эти два файла — одно целое. Все переменные и функции, объявленные в utils.go, будут доступны в main.go без всяких импортов.

Работа с подпапками (вложенные пакеты)

Если вы создадите папку mathutils внутри своего проекта, вы должны будете объявить там другой пакет: package mathutils. Чтобы использовать функции из этой папки в основном файле, вам придется их импортировать:

Здесь вступает в силу правило видимости: * Если имя функции или переменной начинается с заглавной буквы (Calculate), она «экспортируемая» (публичная) и видна из других пакетов. * Если с строчной (calculate), она видна только внутри своего пакета.

Типичные ошибки новичков при работе с модулями

Отсутствие go.mod: Новички часто создают файл .go и пытаются его запустить, забыв про go mod init. Всегда начинайте проект с инициализации модуля.

Неправильное расположение файлов: Go ожидает, что все файлы одного пакета лежат в одной папке. Одна папка — один пакет.

Забытый go mod tidy: Когда вы используете внешние библиотеки, ваш файл go.mod должен обновиться. Команда go mod tidy сканирует код, добавляет недостающие зависимости и удаляет неиспользуемые.

Практические нюансы: компиляция под разные платформы

Одна из самых мощных функций Go — кросс-компиляция. Вы можете сидеть на Windows, но собрать программу, которая будет работать на сервере с Linux. Достаточно изменить переменные окружения перед сборкой.

В терминале (PowerShell) это выглядит так:

* GOOS — целевая операционная система (linux, windows, darwin для macOS). * GOARCH — архитектура процессора (amd64, arm64).

Роль комментариев и документации

В Go документация — это часть культуры. Вы встретите два типа комментариев:

Однострочные: // это комментарий.

Многострочные: / это блок комментариев /.

Если вы напишете комментарий прямо перед объявлением функции без пустой строки, инструмент go doc воспримет его как официальное описание этой функции:

Замыкание мысли

Первая программа на Go — это не просто вывод текста на экран. Это вход в экосистему, где порядок, чистота и явность ценятся превыше всего. Мы научились создавать «паспорт» проекта через go.mod, организовывать код в пакеты и использовать мощные инструменты командной строки. Теперь, когда наше рабочее пространство организовано, мы готовы переходить к кирпичикам, из которых строится любая логика — к переменным и типам данных.

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

Представьте, что вы переезжаете в новый дом. У вас есть десятки коробок: в одних лежат тяжелые книги, в других — хрупкая посуда, в третьих — одежда. Чтобы не запутаться и не раздавить сервиз томами энциклопедии, вы подписываете каждую коробку и выбираете для неё подходящий размер. В программировании происходит ровно то же самое. Переменные — это подписанные коробки, а типы данных — это правила, которые определяют, что именно можно положить внутрь и сколько места это займет в памяти компьютера.

В языке Go (Golang) порядок в этих «коробках» возведен в абсолют. Это язык со статической типизацией, а значит, если вы решили, что в переменной будет храниться число, вы не сможете внезапно положить туда строку с текстом. На первый взгляд это кажется ограничением, но именно эта строгость делает программы на Go быстрыми и надежными.

Анатомия переменной: имя, тип и значение

Когда мы пишем код, мы оперируем данными. Но процессору компьютера неудобно работать с абстрактными понятиями вроде «имя пользователя» или «цена товара». Он видит только бесконечные адреса в оперативной памяти, похожие на . Переменные позволяют нам, людям, дать этим адресам понятные имена.

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

Полная форма объявления: ключевое слово var

Самый явный способ заявить о создании переменной — использовать слово var.

Разберем эту строку по частям:

var — сигнализирует компилятору: «Внимание, я создаю новую переменную».

speed — имя (идентификатор). По этому имени мы будем обращаться к данным.

int — тип данных (сокращение от integer — целое число).

= — оператор присваивания, который кладет значение в коробку.

90 — само значение.

Вывод типа (Type Inference)

Go — умный язык. Если вы сразу присваиваете значение, компилятор может сам догадаться, какой тип данных использовать.

Это удобно, но важно помнить: тип фиксируется навсегда. Если message стала строкой, она останется ей до конца работы программы.

Краткое объявление через оператор :=

Внутри функций (например, внутри main) программисты на Go чаще всего используют «моржовый оператор» :=. Он позволяет опустить слово var и тип.

Это самый лаконичный способ. Однако у него есть два жестких правила:

Он работает только внутри функций. На уровне пакета (вне func) нужно использовать var.

Он всегда создает новую переменную. Если переменная с таким именем уже была объявлена выше в этом же блоке кода, возникнет ошибка компиляции.

Целые числа: от байта до гигантских величин

Числа — это фундамент любой программы. В Go целые числа делятся на две большие группы: знаковые (могут быть отрицательными) и беззнаковые (только ноль и положительные).

Знаковые целые числа (int)

Типы int8, int16, int32, int64 различаются количеством бит, которые они занимают в памяти. Цифра в названии указывает на разрядность.

Например, int8 занимает 8 бит (1 байт). В нем можно хранить значения от до . Почему именно столько? Один бит уходит на хранение знака (плюс или минус), а оставшиеся 7 бит — на само число. Формула диапазона для типа intN выглядит так: от до .

Если мы попробуем записать число в переменную типа int8, произойдет переполнение, и компилятор выдаст ошибку (или программа поведет себя непредсказуемо при вычислениях).

Наиболее часто используется просто тип int. Его размер зависит от архитектуры вашего компьютера: на 64-битной системе это будет 64 бита, на 32-битной — 32 бита.

Беззнаковые целые числа (uint)

Если вы точно знаете, что значение не может быть отрицательным (например, количество подписчиков или возраст), используются типы uint (unsigned integer).

uint8 (диапазон от до ). Этот тип также имеет псевдоним byte. Когда мы работаем с сырыми данными файлов или сетевым трафиком, мы работаем с «срезами байтов».

uint16, uint32, uint64.

> Инсайт профессора: > Выбор правильного размера числа — это баланс между экономией памяти и безопасностью. В современных десктопных приложениях мы почти всегда используем int или int64. Однако в высоконагруженных системах или при разработке для микроконтроллеров, где каждый килобайт на счету, программисты тщательно выбирают между int8 и int16.

Числа с плавающей точкой: точность имеет значение

Для работы с дробными числами (цена товара , число ) в Go используются типы float32 и float64.

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

float32: обеспечивает точность около 7 десятичных цифр.

float64: обеспечивает точность около 15 десятичных цифр.

В Go по умолчанию при использовании := дробному числу присваивается тип float64, так как он минимизирует ошибки округления.

Никогда не используйте float для хранения финансовых данных (денег). Ошибки округления могут накапливаться. Для денег в серьезных проектах используют целые числа (хранят копейки/центы вместо рублей/долларов) или специальные пакеты для высокоточной арифметики.

Логический тип (bool): мир черного и белого

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

Логические переменные — это «переключатели» в вашей программе. На них строятся все условия.

Мы подробно разберем их использование в главе про условия, но сейчас важно запомнить: в Go нельзя превратить число в логический тип. В языке C число — это «истина», а — «ложь». В Go это не сработает. true — это только true.

Строки: не просто текст, а последовательность байтов

Тип string в Go предназначен для хранения текста. Строки заключаются в двойные кавычки:

Особенности строк в Go:

Неизменяемость (Immutability): Вы не можете изменить один символ внутри строки после того, как она создана. Чтобы изменить строку, нужно собрать новую из частей старой.

UTF-8 по умолчанию: Go "из коробки" прекрасно работает с кириллицей, эмодзи и любыми другими символами. Каждая строка — это, по сути, доступная только для чтения последовательность байтов.

Если вам нужно вставить в строку кавычки или перенос строки, используются спецсимволы:

\n — переход на новую строку.

\t — табуляция.

\" — двойная кавычка.

А если вам нужно написать многострочный текст (например, SQL-запрос или HTML-шаблон), используются обратные кавычки (бэктики):

В таких строках (raw string literals) все символы воспринимаются буквально, и экранирование через \ не требуется.

Значения по умолчанию (Zero Values)

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

| Тип данных | Значение по умолчанию | | :--- | :--- | | int, float | 0 | | bool | false | | string | "" (пустая строка) | | Указатели, интерфейсы | nil |

Это делает код более предсказуемым. Вы всегда знаете, что если вы объявили var count int, то там лежит именно , а не случайное число .

Преобразование типов: строгость закона

Go запрещает любые неявные операции с разными типами. Вы не можете сложить int и int64, даже если числа в них небольшие. Вы не можете сложить int и float64.

Чтобы выполнить такую операцию, нужно явно привести один тип к другому:

Преобразование выглядит как вызов функции: тип(переменная). При преобразовании из float в int дробная часть просто отбрасывается (не округляется, а именно отрезается).

Константы: то, что не меняется

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

Константы помогают избежать «магических чисел» в коде. Читать код, где написано if days > DaysInWeek, гораздо приятнее, чем if days > 7. Кроме того, константы в Go вычисляются на этапе компиляции, что дает небольшую прибавку к производительности.

Нюансы именования переменных

В Go принят стиль MixedCaps или camelCase. Мы не используем подчеркивания в именах переменных.

Плохо: user_id, max_height.

Хорошо: userID, maxHeight.

Также в Go существует правило: чем меньше область видимости переменной, тем короче может быть её имя. В коротком цикле допустимо использовать i для индекса, но для глобальной настройки лучше использовать описательное имя вроде RetryLimit.

Помните из предыдущей лекции: если имя начинается с большой буквы (MaxCount), переменная будет видна за пределами пакета (экспортируемая). Если с маленькой (maxCount) — она останется «приватной» внутри пакета.

Практический пример: расчет стоимости заказа

Давайте объединим всё изученное в небольшую программу. Допустим, нам нужно рассчитать стоимость корзины товаров с учетом скидки.

В этом примере мы видим взаимодействие разных типов:

string для названия.

float64 для цены, так как цена может иметь копейки.

int для количества, так как нельзя купить полторы клавиатуры.

Явное преобразование float64(quantity) для математической операции.

Если вы забудете преобразовать тип, Go не даст вам скомпилировать программу. Это может раздражать новичков, но это спасает от сотен трудноуловимых багов в будущем, когда вы будете работать с огромными финансовыми или инженерными системами.

Особенности работы с памятью и типами

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

Например, int32 всегда занимает 4 байта (32 бита). Даже если вы положите туда число , оно все равно будет занимать 4 байта. Строки устроены сложнее. Сама переменная типа string — это небольшая структура, которая содержит адрес в памяти (где начинается текст) и длину строки. Поэтому копирование строк в Go происходит очень быстро: копируется только адрес и длина, а не весь текст целиком.

Псевдонимы типов (Type Aliases)

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

byte — это то же самое, что uint8. Используется для работы с данными.

rune — это то же самое, что int32. Используется для хранения одного символа Unicode.

Если вы хотите перебрать строку по символам, вы будете работать именно с rune. Это важно, потому что кириллический символ (например, 'Я') в кодировке UTF-8 занимает 2 байта, и обычный byte не сможет его вместить целиком.

Как не запутаться в типах

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

Нужно целое число? Используйте int.

Нужна большая точность или работа с дробными числами? Используйте float64.

Работаете с текстом? Однозначно string.

Нужно условие «да/нет»? Используйте bool.

Если вы работаете с внешними API или базами данных, там типы обычно прописаны в документации (например, int64 для ID пользователя).

Go поощряет минимализм. Не стоит использовать int8 только потому, что «число маленькое», если у вас нет миллионов таких чисел в памяти. Используйте стандартный int, это сделает ваш код чище и избавит от лишних преобразований типов при вызове стандартных функций.

В следующей главе мы научим компьютер принимать решения на основе этих данных: использовать bool в условиях if и повторять действия с помощью циклов. Но фундамент — это понимание того, как данные лежат в памяти, и почему 10 и "10" — это абсолютно разные сущности для вашего процессора.