Go для начинающих: от основ к практике

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

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

Что такое Go и почему он стал популярным?

Язык Go (часто называемый Golang) был разработан внутри компании Google в 2007 году, а в 2009 году представлен публике. Его создатели — легенды компьютерных наук: Роб Пайк, Кен Томпсон и Роберт Гризмер. Они стремились создать язык, который сочетал бы в себе производительность C++ и простоту чтения кода, свойственную Python.

!Диаграмма Венна, показывающая баланс качеств языка Go

Ключевые особенности Go:

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

Настройка окружения

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

Шаг 1: Установка Go

Перейдите на официальный сайт The Go Programming Language.

Скачайте установочный файл для вашей операционной системы (Windows, macOS или Linux).

Запустите установщик и следуйте инструкциям.

Чтобы проверить, что установка прошла успешно, откройте терминал (или командную строку) и введите:

Вы должны увидеть сообщение, похожее на go version go1.21.0 darwin/arm64.

Шаг 2: Выбор редактора кода

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

* VS Code: Бесплатный, легкий и мощный редактор. Обязательно установите официальное расширение «Go» от команды Go Team at Google. * GoLand: Полноценная IDE от JetBrains. Платная, но очень умная среда разработки.

Ваша первая программа

По традиции начнем с программы «Hello, World!». Создайте файл с названием main.go и напишите в нем следующий код:

Разбор структуры программы

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

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

import "fmt": Команда подключения внешних пакетов. Пакет fmt (от слова format) отвечает за форматирование ввода и вывода (например, вывод текста на экран).

func main() { ... }: Функция main — это точка входа в программу. Выполнение кода всегда начинается именно с неё.

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

Переменные и типы данных

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

Объявление переменных

Существует два основных способа создания переменных.

1. Полная форма (через ключевое слово var):

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

2. Краткая форма (через :=):

Самый популярный способ внутри функций. Go сам определяет тип переменной на основе значения справа.

> Важно: Краткую форму := можно использовать только внутри функций. На уровне пакета (вне функций) всегда используется var.

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

Вот основные типы, с которыми вы будете работать чаще всего:

* bool: логический тип (true или false). * string: строка (набор символов в кодировке UTF-8). * int, int64: целые числа. * float64: числа с плавающей точкой.

Zero Values (Нулевые значения)

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

* 0 для чисел. * false для bool. * "" (пустая строка) для string. * nil для указателей и сложных структур.

Пример:

Операторы

Операторы в Go похожи на другие C-подобные языки.

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

* + (сложение) * - (вычитание) (умножение) * / (деление) * % (остаток от деления)

Обратите внимание на деление целых чисел. Если вы делите два целых числа, результат тоже будет целым (дробная часть отбрасывается).

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

Используются для построения условий:

* && (логическое И) * || (логическое ИЛИ) * ! (логическое НЕ)

Управление потоком выполнения

Программа редко бывает линейной. Нам нужно принимать решения и повторять действия. Для этого в Go есть условные операторы и циклы.

Условный оператор if / else

Синтаксис if в Go прост и лаконичен. Круглые скобки вокруг условия не нужны, но фигурные скобки {} обязательны.

Особенность Go: в if можно добавить краткую инструкцию перед проверкой условия. Это часто используется для обработки ошибок.

Конструкция switch

Если у вас много условий, switch будет чище и понятнее, чем множество if-else.

Важное отличие от других языков: В Go не нужно писать break в конце каждого case. Выполнение кода автоматически прерывается после выполнения подходящего блока. Если вы хотите, чтобы выполнение перешло к следующему блоку (как в C++), нужно явно написать ключевое слово fallthrough.

Циклы: только for

В Go есть только одно ключевое слово для циклов — for. Но оно покрывает все сценарии, для которых в других языках используются while и do-while.

!Три варианта синтаксиса цикла for в Go

1. Классический цикл (как в C/Java):

2. Цикл с условием (аналог while):

Мы просто опускаем инициализацию и пост-действие.

3. Бесконечный цикл:

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

Для управления циклами используются стандартные команды: * break: немедленно прерывает цикл. * continue: пропускает текущую итерацию и переходит к следующей.

Заключение

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

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

Работа с данными: строки, массивы, слайсы и карты

В предыдущих статьях мы научились создавать простые переменные, такие как числа и логические значения, и управлять потоком выполнения программы. Но реальный мир состоит из списков, текстов и словарей. Как сохранить список пользователей? Как обработать текст сообщения? Как найти телефон по имени?

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

Строки (Strings)

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

Строка — это набор байтов

В Go строка (string) — это неизменяемая последовательность байтов. Исходный код Go всегда хранится в кодировке UTF-8, поэтому строковые литералы также интерпретируются как UTF-8.

Попробуем узнать длину строки:

Почему длина слова «Го» равна 4? Потому что функция len() возвращает количество байтов, а не символов. В кодировке UTF-8 латинские буквы занимают 1 байт, а кириллические — 2 байта (некоторые символы и эмодзи могут занимать до 4 байт).

Руны (Runes)

Чтобы работать с «символами» в привычном понимании, в Go используется понятие Rune (руна). Руна — это псевдоним для типа int32, который хранит числовой код Unicode символа.

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

Итерация по строке

При переборе строки через цикл for range, Go умно обрабатывает кодировку и выдает нам руны, а не байты.

Обратите внимание: индексы будут идти не подряд (0, 2, 4...), так как каждая буква занимает 2 байта.

Массивы (Arrays)

Массив — это нумерованная последовательность элементов одного типа фиксированной длины.

Объявление и инициализация

Размер массива является частью его типа. Это значит, что [5]int и [10]int — это абсолютно разные типы данных.

Особенности массивов в Go

Фиксированный размер: Вы не можете добавить элемент в массив или изменить его размер после создания.

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

Из-за этих ограничений массивы в чистом виде используются в Go редко. Чаще всего они служат основой для слайсов.

Слайсы (Slices)

Слайс (или срез) — это, пожалуй, самая часто используемая структура данных в Go. Это «динамический массив», который может менять свой размер.

!Структура слайса: указатель на массив, длина и вместимость

Слайс состоит из трех компонентов:

Pointer: Указатель на начало сегмента в базовом массиве.

Length (len): Количество элементов, которые содержит слайс сейчас.

Capacity (cap): Количество элементов, которые помещаются в базовый массив, начиная с индекса слайса.

Создание слайсов

В отличие от массива, в квадратных скобках не указывается размер:

Динамическое расширение: append

Чтобы добавить элемент, используется встроенная функция append. Она возвращает новый слайс.

Как это работает? Если в базовом массиве есть место (capacity > length), append просто записывает значение. Если места нет, Go создает новый массив (обычно в 2 раза больше), копирует туда старые данные, добавляет новые и возвращает слайс, указывающий на новый массив.

Важная особенность: связь с массивом

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

Карты (Maps)

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

Объявление и инициализация

Тип описывается как map[ТипКлюча]ТипЗначения.

> Внимание: Нулевое значение для карты — nil. Вы можете читать из nil карты, но попытка записи в неё вызовет панику (аварийную остановку программы). Всегда инициализируйте карту через make или литерал.

Операции с картами

Добавление и обновление:

Получение значения:

Удаление:

Проверка наличия ключа

Что будет, если запросить ключ, которого нет? Go не выдаст ошибку, а вернет «нулевое значение» для типа значения (0 для int, "" для string).

Но как отличить, что пользователю действительно 0 лет, от того, что пользователя нет в базе? Используется идиома «comma ok»:

Порядок обхода

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

Заключение

Мы рассмотрели основные структуры данных в Go:

* Строки — для работы с текстом (помните про UTF-8 и руны). * Массивы — база фиксированного размера. * Слайсы — гибкий инструмент, который вы будете использовать в 90% случаев вместо массивов. * Карты — для хранения пар «ключ-значение» и быстрого поиска.

Понимание того, как работают слайсы (length vs capacity) и карты (проверка наличия ключа), убережет вас от множества популярных ошибок новичков. В следующей статье мы научимся создавать собственные типы данных с помощью структур (structs), что позволит нам моделировать реальные объекты.

Архитектура кода: функции, указатели, структуры и методы

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

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

Функции: строительные блоки логики

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

Объявление и параметры

Базовый синтаксис выглядит так:

Пример простой функции сложения:

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

Множественный возврат значений

Одна из самых мощных особенностей Go — возможность возвращать из функции несколько значений. Это кардинально меняет подход к обработке ошибок.

В других языках (Java, Python) часто выбрасывают исключения. В Go принято возвращать результат и ошибку как два отдельных значения.

Вызов такой функции выглядит так:

Отложенный вызов: defer

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

Это незаменимый инструмент для очистки ресурсов: закрытия файлов, разрыва сетевых соединений или освобождения блокировок.

Вывод программы:

Начало

Работа...

Конец

Если в функции несколько defer, они выполняются в порядке LIFO (Last In, First Out — последним пришел, первым ушел), как стопка тарелок.

Указатели: карта памяти

Тема указателей часто пугает новичков, но в Go они реализованы намного безопаснее и проще, чем в C++. Указатель — это переменная, которая хранит не само значение (например, число 42), а адрес ячейки памяти, где это значение лежит.

!Визуализация разницы между значением и указателем на значение

Операторы & и *

* & (амперсанд) — взятие адреса. Позволяет узнать, где в памяти лежит переменная. (звездочка) — разыменование. Позволяет получить или изменить значение, лежащее по этому адресу.

Зачем нужны указатели?

Эффективность: Если у вас есть огромная структура данных (например, текст книги), передавать её в функцию по значению (копировать целиком) дорого. Проще передать маленький адрес (указатель).

Изменяемость: По умолчанию Go передает аргументы в функции по значению (создает копию). Если функция должна изменить исходную переменную, ей нужно передать указатель на эту переменную.

Пример без указателя (не сработает):

Пример с указателем (сработает):

Структуры: создание собственных типов

До сих пор мы пользовались встроенными типами (int, string, bool). Но реальный мир состоит из сложных объектов. Пользователь сайта — это не просто строка, это набор данных: имя, email, возраст, статус.

В Go для этого используются структуры (struct).

Объявление структуры

Теперь User — это полноценный тип данных, такой же, как int.

Создание и использование

Если вы не укажете значение для поля, оно получит «нулевое значение» (0, "", false).

Вложенные структуры

Структуры могут содержать другие структуры. Это позволяет строить сложные иерархии данных.

Методы: оживляем структуры

В объектно-ориентированных языках (как Java или C#) методы находятся внутри классов. В Go классов нет, но вы можете объявить метод для любого пользовательского типа (чаще всего для структур).

Метод — это просто функция, у которой есть особый аргумент — получатель (receiver). Он указывается в скобках перед именем функции.

Синтаксис метода

Value Receiver vs Pointer Receiver

Это критически важный момент в Go. При объявлении метода вы должны выбрать, как передавать структуру: копией или по ссылке.

1. Value Receiver (Получатель-значение): (u User)

* В метод передается копия структуры. * Метод не может изменить исходный объект. * Безопасно, но если структура большая, копирование занимает память.

2. Pointer Receiver (Получатель-указатель): (u *User)

* В метод передается адрес структуры. * Метод может изменять исходный объект. * Копирования не происходит (быстро).

!Различие между Value Receiver и Pointer Receiver

Когда что использовать?

Существует простое правило: Если методу нужно изменить состояние объекта — используйте Pointer Receiver (User). Если структура большая и копировать её дорого — используйте Pointer Receiver (User). * Если структура маленькая и неизменяемая — можно использовать Value Receiver (User). * Для единообразия: если хотя бы один метод типа имеет указатель-получатель, рекомендуется делать все методы этого типа с указателем.

Практический пример: Банковский счет

Давайте соберем всё вместе в небольшом примере.

Заключение

Сегодня мы заложили фундамент архитектуры приложений на Go. Мы разобрали:

Функции и их суперспособности: множественный возврат и defer.

Указатели, которые позволяют эффективно работать с памятью и изменять данные.

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

Методы, которые связывают данные и поведение.

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

Экосистема и надежность: модули, обработка ошибок и работа с файлами

Мы уже прошли большой путь: от «Hello, World!» до создания собственных структур данных и методов. Теперь наши программы умеют считать и хранить данные в памяти. Но что происходит, когда программа разрастается до тысяч строк? Как сохранить данные после выключения компьютера? И, самое главное, как сделать так, чтобы программа не падала при первой же неудаче?

В этой статье мы превратим наши скрипты в полноценные инженерные решения. Мы разберем три кита надежной разработки на Go: модульную систему, философию обработки ошибок и работу с файловой системой.

Пакеты и модули: организация кода

До сих пор мы писали весь код в одном файле main.go. В реальных проектах код разбивается на множество файлов и папок. В Go единица организации кода называется пакетом (package).

Что такое пакет?

Пакет — это папка с файлами .go. Все файлы в одной папке должны иметь одинаковую директиву package имя_пакета в первой строке.

!Структура файлов и папок в типичном Go-проекте

Экспорт: Магия заглавной буквы

В Go нет ключевых слов public, private или protected, как в Java или C++. Вместо этого используется гениально простое правило регистра:

* Если имя (функции, переменной, структуры) начинается с Заглавной буквы, оно экспортируемое (публичное). Его видят другие пакеты. * Если имя начинается со строчной буквы, оно неэкспортируемое (приватное). Оно доступно только внутри текущего пакета.

Пример:

Файл math/operations.go:

Файл main.go:

Go Modules: Управление зависимостями

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

Модуль — это коллекция пакетов, имеющая файл go.mod в корне. Этот файл — паспорт вашего проекта.

Как начать новый проект:

Создайте папку проекта.

Откройте терминал в этой папке.

Инициализируйте модуль командой:

Имя модуля (в примере github.com/username/myproject) служит уникальным идентификатором. Даже если вы не публикуете код на GitHub, принято использовать такой формат именования.

После этой команды появится файл go.mod. Теперь вы можете создавать вложенные папки (пакеты) и импортировать их, используя полный путь: import "github.com/username/myproject/mypackage".

Обработка ошибок: Errors are Values

В большинстве языков (Python, Java, C#) для обработки ошибок используется механизм исключений (try-catch). Программа «выбрасывает» ошибку, и выполнение перепрыгивает в блок catch.

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

Интерфейс error

В Go есть встроенный тип error. Если операция прошла успешно, ошибка равна nil (пустота). Если что-то пошло не так, там будет объект с описанием проблемы.

!Логика проверки ошибок в Go

Стандартный паттерн проверки

Вы будете писать этот код тысячи раз. Это идиома Go:

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

Создание собственных ошибок

Иногда нам нужно вернуть свою ошибку. Для этого используются пакеты errors и fmt.

Простая ошибка:

Ошибка с форматированием (динамическими данными):

> Никогда не игнорируйте ошибки, используя нижнее подчеркивание _, если вы не уверены на 100%, что это безопасно. Игнорирование ошибок — самый быстрый путь к нестабильному приложению.

Работа с файлами

Любая полезная программа взаимодействует с внешним миром. Чтение и запись файлов — базовая операция ввода-вывода (I/O).

В Go за это отвечает пакет os (операционная система) и вспомогательные пакеты io и bufio.

Чтение файла целиком

Если файл небольшой (например, конфиг), проще всего прочитать его сразу в память.

Запись в файл

Аналогично чтению, есть простая функция для записи:

Построчное чтение (для больших файлов)

Если файл весит гигабайты, читать его целиком в память нельзя — оперативная память закончится. Нужно читать его поток, строку за строкой. Здесь нам поможет os.Open и bufio.Scanner.

И здесь мы снова встретимся с defer, который мы изучили в прошлой статье.

Работа с путями

В Windows пути используют обратный слэш \, а в Linux и macOS — прямой /. Чтобы ваша программа работала везде, используйте пакет path/filepath.

Заключение

Сегодня мы сделали огромный шаг вперед. Теперь вы знаете:

Как структурировать код с помощью пакетов и управлять видимостью через регистр букв.

Как инициализировать проект с помощью go mod.

Как правильно обрабатывать ошибки, не используя try-catch.

Как читать и писать файлы, корректно управляя ресурсами через defer.

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

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

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

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

Проект: CLI Менеджер задач

Мы напишем консольную утилиту (CLI — Command Line Interface) для управления списком дел. Это классическая задача, которая позволяет поработать с:

* Структурами и слайсами (хранение данных). * Файлами (сохранение данных между запусками). * Сериализацией JSON (формат обмена данными). * Аргументами командной строки (взаимодействие с пользователем).

Назовем наше приложение GoDo.

!Архитектура нашего приложения: от ввода команды до сохранения в файл

Шаг 1: Структура данных

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

Создадим файл main.go и опишем структуру:

Обратите внимание на текст в кавычках справа: ` json:"id" . Это теги структур. Они подсказывают пакету encoding/json, как называть поля при сохранении в файл. В Go поля структур пишутся с Большой Буквы (чтобы быть экспортируемыми), но в JSON принято использовать маленькие буквы.

Шаг 2: Сохранение и загрузка (JSON)

Чтобы наши задачи не исчезали после закрытия программы, мы будем хранить их в файле tasks.json. Нам понадобятся две вспомогательные функции.

Для работы с JSON в Go есть стандартный пакет encoding/json. Функция Marshal превращает структуру в байты (JSON), а Unmarshal — наоборот.

Шаг 3: Реализация команд

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

Добавление задачи:

Просмотр списка:

Шаг 4: Точка входа и аргументы CLI

Как программа узнает, что мы хотим сделать? Мы будем использовать аргументы командной строки. В Go они доступны через слайс os.Args.

* os.Args[0] — это имя самой программы. * os.Args[1] — это первая команда (например, add или list). * os.Args[2] — это аргумент команды (например, текст задачи).

Обновим функцию main:

Запуск и проверка

Теперь откройте терминал в папке с проектом и попробуйте:

go run main.go list (Выведет: Список задач пуст)

go run main.go add "Изучить Go"

go run main.go add "Написать проект"

go run main.go list

Вы увидите список ваших задач! Даже если вы выключите компьютер и вернетесь завтра, задачи останутся в файле tasks.json.

Вектор развития: Что учить дальше?

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

1. Конкурентность (Concurrency)

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

В Go запуск параллельной задачи делается добавлением всего одного слова — go.

Горутины (Goroutines) — это очень легкие потоки. Вы можете запустить их тысячи и даже миллионы на одном компьютере. Для общения между ними используются каналы (channels).

!Последовательное выполнение против конкурентного

2. Веб-разработка

Go — язык интернета. На нем написаны Docker, Kubernetes и Twitch. Стандартная библиотека Go настолько мощная, что позволяет поднять веб-сервер в 5 строк кода без сторонних фреймворков:

Запустив этот код, вы сможете зайти в браузере на localhost:8080 и увидеть ответ вашего сервера.

3. Работа с базами данных

Реальные приложения хранят данные не в JSON-файлах, а в базах данных (PostgreSQL, MySQL). В Go есть стандартный интерфейс database/sql, который позволяет безопасно и быстро работать с SQL-запросами.

Как продолжать обучение?

Вы заложили прочный фундамент. Чтобы стать профессионалом, следуйте этому плану:

Читайте код стандартной библиотеки. Go написан на Go. Откройте исходники пакета fmt или net/http` — это лучшие учебники по стилю и архитектуре.

Пишите пет-проекты. Напишите бота для Telegram, сокращатель ссылок или парсер погоды. Практика — лучший учитель.

Изучите Go by Example. Это отличный ресурс с примерами кода на все случаи жизни.

Заключение курса

Мы начали с простых переменных и дошли до создания полноценного CLI-приложения с базой данных на JSON. Вы узнали, что Go — это язык, который ценит простоту, надежность и читаемость кода.

Теперь у вас есть инструменты, чтобы строить сложные системы. Не бойтесь ошибок, экспериментируйте и помните: каждый эксперт когда-то был новичком, который не сдался.

Удачи в мире Go!