МОДУЛЬ 1 · УРОК 1.4

Первая программа. Hello, World!

Пишем, разбираем по строкам и запускаем классическую первую программу на Go

В прошлом уроке мы установили Go, редактор кода и познакомились с терминалом. Рабочее место готово — а значит, пора наконец-то писать код! Сегодня вы создадите свою самую первую программу. Она будет простой: всего несколько строк. Но за каждой из этих строк стоит важная идея, которую мы подробно разберём. К концу урока вы будете точно понимать, что делает каждое слово в Go-файле, научитесь запускать программу через терминал и даже сможете писать код прямо в браузере — вообще без установки чего-либо. Готовы? Тогда начнём.

👋 Почему именно Hello, World?

В мире программирования существует давняя традиция: первая программа, которую пишет любой новичок на любом языке, выводит на экран фразу «Hello, World!». Эта традиция зародилась ещё в 1978 году, когда Брайан Керниган и Деннис Ритчи написали книгу по языку C. С тех пор прошло почти полвека, но традиция жива до сих пор — и на то есть причины.

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

Забавный факт: Go был создан в Google, и один из его авторов — тот самый Кен Томпсон, который вместе с Деннисом Ритчи придумал язык C и операционную систему Unix. Так что, когда вы пишете Hello World на Go, вы продолжаете традицию, начатую теми же самыми людьми.

📁 Создаём проект

Прежде чем писать код, нужно создать для него отдельное место. В прошлом уроке мы создали папку для проектов. Теперь внутри неё создадим папку для нашей первой программы. Откройте терминал и выполните команды:

mkdir hello
cd hello

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

go mod init hello

Эта команда создаст файл go.mod в вашей папке. Он сообщает Go: «Здесь живёт проект с именем hello». Пока не вникайте в детали — просто запомните: перед началом любого нового проекта на Go нужно выполнить go mod init.

Теперь создайте файл с именем main.go. Это можно сделать через VS Code: откройте папку hello в редакторе (команда code . в терминале, если вы уже в нужной папке) и создайте новый файл. Расширение .go — это стандартное расширение для файлов с кодом на Go, точно так же как .txt для текстовых файлов или .jpg для картинок.

💻 Полный код программы

Вот программа целиком. Напишите (именно напишите, а не скопируйте — так вы лучше запомните) этот код в файл main.go:

package main

import "fmt"

func main() {
    fmt.Println("Hello, World!")
}

Всего шесть строк. Выглядит просто, но каждая из них несёт важный смысл. Давайте разберём программу строка за строкой — подробно и без спешки.

🔍 Разбираем каждую строку

Строка 1: package main

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

package main — это особый пакет. Он говорит Go: «Этот файл — точка входа в программу. Именно отсюда нужно начинать выполнение». Если вы назовёте пакет как-нибудь иначе (например, package utils), Go не будет знать, что это запускаемая программа. Запомните: программа, которую можно запустить, всегда начинается с package main.

Строка 2: пустая строка

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

Строка 3: import "fmt"

Слово import означает «импортировать», то есть подключить. Мы подключаем пакет fmt (сокращение от английского слова format — «формат»). Этот пакет входит в стандартную библиотеку Go и содержит функции для работы с текстом: вывод на экран, форматирование строк и так далее.

Зачем импортировать? Дело в том, что Go устроен по принципу минимализма. В самом языке есть только базовые конструкции: переменные, циклы, условия. А всё остальное — вывод текста, работа с файлами, сетевые запросы — находится в отдельных пакетах. Это как набор инструментов: вы не таскаете с собой все ключи сразу, а берёте только те, которые нужны для конкретной задачи.

Обратите внимание: название пакета заключено в двойные кавычки — "fmt". Это обязательно. Go строг к синтаксису, и если вы забудете кавычки, программа не скомпилируется.

Строка 4: ещё одна пустая строка

Снова визуальный разделитель. Отделяет секцию импортов от секции функций. Это часть стиля Go — и, кстати, Go очень серьёзно относится к стилю кода. Позже мы познакомимся с инструментом go fmt, который автоматически форматирует код по стандартам Go. Но об этом в будущих уроках.

Строка 5: func main() {

Здесь мы объявляем функцию. Слово func — сокращение от function (функция). Функция — это именованный блок кода, который выполняет какое-то действие. Вы можете думать о функции как о рецепте: вы даёте ему имя (например, «Рецепт борща»), а внутри описываете пошаговые инструкции.

main — это имя функции. И, как и package main, эта функция особенная. Когда вы запускаете Go-программу, выполнение всегда начинается с функции main в пакете main. Это точка входа — самая первая инструкция, которую выполнит компьютер. Без этой функции Go скажет: «Я не знаю, откуда начинать», и программа не запустится.

Круглые скобки () после имени — это место для параметров (входных данных). У main параметров нет, поэтому скобки пустые. Фигурная скобка { открывает тело функции — то есть начинает блок инструкций, которые будут выполнены.

Строка 6: fmt.Println("Hello, World!")

Вот она — единственная инструкция нашей программы. Разберём её по частям:

fmt — это тот самый пакет, который мы импортировали. Через точку мы обращаемся к его содержимому.

Println — это функция из пакета fmt. Её имя расшифровывается как Print line — «напечатать строку». Она выводит переданный ей текст на экран и переводит курсор на следующую строку (поэтому ln в конце — от слова line).

"Hello, World!" — это аргумент, который мы передаём функции. Текст в двойных кавычках называется строковым литералом. Проще говоря — это просто текст. Вы можете заменить его на любой другой: "Привет, мир!", "Я учу Go!" или что угодно.

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

Строка 7: }

Закрывающая фигурная скобка. Она завершает тело функции main. Каждая открывающая скобка { должна иметь парную закрывающую }. Если забудете — Go выдаст ошибку компиляции. Это как открытая и закрытая скобка в математике: (2 + 3) — всё корректно, (2 + 3 — нет.

💡 Подсказка: обратите внимание — в Go нет точек с запятой в конце строк, в отличие от C, Java или JavaScript. Компилятор Go сам расставляет их «за кулисами». Это одна из особенностей Go, которая делает код чище и проще для чтения.

📐 Структура любого Go-файла

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

1. Объявление пакета — package имя. Всегда первая строка.

2. Импорты — import "пакет". Подключаем нужные пакеты.

3. Функции и остальной код — func имя() { ... }. Логика программы.

Этот порядок обязателен. Вы не можете сначала написать функцию, а потом объявить пакет — Go выдаст ошибку. Структура жёсткая, но именно благодаря этому код на Go всегда выглядит единообразно. Открыв любой Go-файл, написанный кем угодно, вы сразу знаете, где что искать.

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

import (
    "fmt"
    "math"
)

Пока нам нужен только fmt, но скоро вы познакомитесь и с другими пакетами.

▶️ Запуск программы: go run

Код написан — пора его запустить! Откройте терминал, убедитесь, что вы находитесь в папке hello (где лежит файл main.go), и выполните команду:

go run main.go

Если вы всё сделали правильно, в терминале появится:

Hello, World!

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

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

Можно также запустить программу, указав не конкретный файл, а точку (текущую папку):

go run .

Go сам найдёт файл с package main в текущей папке и запустит его. Результат будет тем же.

📦 Сборка программы: go build

Команда go run удобна для разработки, но у неё есть ограничение: она каждый раз компилирует код заново. Если вы хотите создать готовый исполняемый файл, который можно передать другому человеку или запускать без установки Go, используйте go build:

go build -o hello

Флаг -o hello задаёт имя выходного файла. После выполнения в папке появится файл hello (на Windows — hello.exe). Это самостоятельная программа. Теперь запустите её:

./hello

На Windows:

hello.exe

Результат тот же: Hello, World!. Но разница важна: этот файл — полностью самостоятельная программа. Вы можете скопировать его на флешку, отправить другу, перенести на другой компьютер — и он запустится, даже если на том компьютере не установлен Go.

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

💡 Когда что использовать? Во время обучения и экспериментов пользуйтесь go run — быстро и удобно. Когда нужно создать готовую программу для использования — go build. Мы в курсе в основном будем использовать go run, чтобы не тратить время на лишние шаги.

🌐 Go Playground — пишем код в браузере

А что если вы хотите быстро попробовать какую-то идею, но не хотите открывать редактор? Или вы за чужим компьютером, где Go не установлен? Для этого существует Go Playground — онлайн-среда, в которой можно писать и запускать код на Go прямо в браузере.

Откройте в браузере:

https://go.dev/play/

Вы увидите текстовое поле с готовым кодом Hello World. Нажмите кнопку Run — и внизу появится результат выполнения. Всё работает на серверах Google, поэтому на вашем компьютере ничего устанавливать не нужно.

Go Playground — отличный инструмент для нескольких ситуаций:

Быстрые эксперименты — хотите проверить, как работает какая-то конструкция? Открыли Playground, написали три строки, нажали Run.
Обучение — можно пробовать примеры из уроков без переключения между редактором и терминалом.
Обмен кодом — нажмите кнопку Share, и вы получите уникальную ссылку. Отправьте её другу или преподавателю — он откроет и увидит ваш код.

💡 Ограничения Playground: код выполняется на сервере, поэтому есть ограничения по времени работы, нельзя работать с файлами и сетью. Для серьёзных проектов используйте локальную установку Go. Но для обучения и экспериментов Playground подходит идеально.

🛠 Типичные ошибки новичков

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

Неиспользованный импорт

Go не позволяет импортировать пакет, если вы его не используете. Если вы написали import "fmt", но нигде не вызвали fmt.Println или другую функцию из fmt, компилятор откажется собирать программу и выдаст ошибку: "fmt" imported and not used. Это не каприз — Go заботится о чистоте кода. Удалите лишний импорт, и ошибка исчезнет.

Скобка на следующей строке

В некоторых языках принято писать открывающую фигурную скобку на следующей строке. В Go так делать нельзя. Скобка { должна стоять на той же строке, что и func main(). Если перенесёте — получите ошибку. Это одно из жёстких правил Go.

Опечатки в названиях

Go чувствителен к регистру: Println и println — это разные вещи. Fmt и fmt — тоже разные. Если вы написали fmt.println с маленькой буквы, Go скажет: cannot refer to unexported name fmt.println. Следите за регистром.

Забыли go mod init

Если вы получаете ошибку вида go: cannot find main module, скорее всего, вы забыли инициализировать модуль. Вернитесь в папку проекта и выполните go mod init hello. После этого попробуйте запустить программу снова.

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

🧪 Попробуйте сами

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

1. Замените текст "Hello, World!" на своё имя. Например: fmt.Println("Привет, меня зовут Алексей!"). Запустите — увидите свой текст.

2. Добавьте вторую строку вывода:

func main() {
    fmt.Println("Hello, World!")
    fmt.Println("Я учу Go!")
}

Программа выведет две строки — каждый Println выводит текст и переходит на новую строку.

3. Попробуйте намеренно сделать ошибку: удалите закрывающую кавычку, уберите скобку, напишите fmtt вместо fmt. Посмотрите, какие сообщения об ошибках покажет Go. Это не сломает ваш компьютер — но поможет научиться читать ошибки компилятора.

4. Откройте Go Playground и попробуйте там же. Меняйте код, нажимайте Run, наблюдайте за результатом. Чем больше экспериментов — тем быстрее вы привыкнете к синтаксису Go.

📋 Итоги урока

Написали и запустили первую программу на Go — классическую Hello, World!
Разобрали структуру Go-файла: package → import → func. Этот порядок обязателен
package main и func main() — точка входа в любую запускаемую Go-программу
import "fmt" подключает пакет для работы с текстом, fmt.Println выводит строку на экран
go run — быстрый запуск для экспериментов, go build — создание готовой программы
Go Playground (go.dev/play) позволяет писать и запускать код прямо в браузере
Go строг к стилю: нет лишних импортов, скобка { на той же строке, регистр имён имеет значение

В следующем уроке мы начнём Модуль 2 и познакомимся с переменными и типами данных. Вы узнаете, как хранить информацию в программе: числа, текст, логические значения. Переменные — это фундамент любой программы, и без них невозможно написать ничего серьёзнее Hello World. До встречи в уроке 2.1!