Модуль 1 · Первые шаги · Урок 1.2

Первая программа на Cargo

Вы создадите проект «Копилка», поймёте, что лежит в его папке, запустите программу и прочитаете первую ошибку компилятора.

Теория + практика~20 минутНовичок

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

Создаём проект командой cargo new

Представьте, что вы начинаете писать книгу. Можно взять чистый лист и самому придумывать, где будет обложка, оглавление и главы. А можно взять готовую папку-заготовку, где всё разложено по местам. Cargo делает вторую вещь: одной командой создаёт проект с правильной раскладкой файлов.

Cargo — официальный менеджер проектов Rust: он создаёт проекты, собирает их, запускает и (позже) подключает чужие библиотеки. Он ставится вместе с Rust, отдельно ничего скачивать не нужно. Откройте терминал, перейдите в папку, где хотите хранить проекты, и введите:

Терминал

cargo new kopilka

Cargo создаст папку kopilka (по-русски — «копилка», так называется наш учебный проект) и напишет, что создан пакет (package) — так в Rust называется проект, который Cargo умеет собирать. Зайдите в неё командой cd kopilka и посмотрите на содержимое:

Вывод

kopilka/
├── Cargo.toml
├── .gitignore
└── src/
    └── main.rs

Cargo.toml — паспорт проекта: название, версия, настройки.
src/main.rs — исходный код программы. Слово src (от source, «исходники») — папка для всего, что вы пишете.
.gitignore — список файлов, которые не нужно сохранять в системе контроля версий Git. Cargo сам создаёт и пустой Git-репозиторий, если Git у вас установлен; пока можно не обращать на это внимания.

Позже, после первой сборки, появятся ещё два «гостя»: папка target/ со всем, что Cargo собрал (её содержимое можно смело удалять, при следующей сборке она вернётся), и файл Cargo.lock — Cargo ведёт его сам, руками его не правят.

Cargo.toml: паспорт проекта

Откройте Cargo.toml в редакторе. Формат файла называется TOML: это просто строки вида «имя = значение», разбитые на разделы в квадратных скобках.

TOML · Cargo.toml

[package]
name = "kopilka"
version = "0.1.0"
edition = "2024"

[dependencies]

Разбор по строкам

[package] — раздел с описанием самого пакета.
name = "kopilka" — имя проекта; по нему же назовётся готовая программа.
version = "0.1.0" — версия вашей программы; пока ничего не меняем.
edition = "2024" — редакция языка. Это что-то вроде «издания учебника»: правила Rust иногда обновляют так, что старый код надо слегка подправить, и такие обновления выходят пачкой раз в несколько лет. cargo new сам выбирает свежую редакцию 2024.
[dependencies] — раздел для чужих библиотек. Он пустой: в этом курсе мы обойдёмся только стандартной библиотекой самого Rust. Как подключать чужие, расскажет курс про Cargo.

fn main и println!

Теперь откройте src/main.rs. Cargo уже положил туда программу, которая здоровается с миром. Заменим приветствие на своё:

Rust · main.rs

// Точка входа программы "Копилка"
fn main() {
    println!("Копилка 0.1");
    println!("Учёт расходов за месяц");
}

Разбор по строкам

// Точка входа ... — комментарий: всё от // до конца строки Rust пропускает. Комментарии пишут для людей.
fn main() { — объявление функции с именем main (fn — от function, «функция»). Так называется точка входа: именно с неё начинается любая программа на Rust. Пустые скобки () значат, что main ничего не принимает на вход; о функциях подробно поговорим позже, пока считайте это обязательной «рамкой».
{ и } — фигурные скобки ограничивают тело функции: всё, что внутри, выполнится при запуске, сверху вниз.
println!("Копилка 0.1"); — напечатать текст и перейти на новую строку (print line). Текст в двойных кавычках — это строка. Точка с запятой ; заканчивает инструкцию, как точка — предложение.
Вторая строка с println! печатается следом, поэтому на экране будет две строки.

Заметили восклицательный знак после println? Он важен. println! — не обычная функция, а макрос. Запомните правило: восклицательный знак значит макрос. Макрос — это «заготовка», которую компилятор разворачивает в настоящий код ещё при сборке. Нам сейчас достаточно знать, что println! всегда пишется с !, а как устроены макросы внутри, мы не трогаем.

Кавычки бывают разные

Для текста в Rust годятся только двойные кавычки "...". Одинарные '...' означают другое — один символ (тип char); с текстом их использовать нельзя.

cargo run, build и check

Код написан, но компьютер читать Rust не умеет: сначала компилятор (rustc) переводит его в машинный код — получается готовая программа. Cargo вызывает компилятор за вас тремя основными командами. Все они выполняются из папки проекта, той, где лежит Cargo.toml.

Команда	Что делает
`cargo run`	собирает программу и сразу запускает её; то, что вы будете вводить чаще всего
`cargo build`	только собирает; готовая программа лежит в `target/debug/kopilka` (на Windows — `target\debug\kopilka.exe`)
`cargo check`	только проверяет код на ошибки, не создавая программу; работает заметно быстрее

Попробуйте cargo run. Cargo сначала сообщит о сборке, потом запустит программу:

Вывод

   Compiling kopilka v0.1.0 (/путь/к/kopilka)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.62s
     Running `target/debug/kopilka`
Копилка 0.1
Учёт расходов за месяц

Первые три строки — рассказ Cargo, последние две — вывод вашей программы. Слово dev означает «режим разработки»: сборка быстрая, но программа не самая шустрая. Быстрый вариант (--release) мы соберём в конце курса.

Совет: cargo check

Пока вы пишете код и просто хотите узнать, нет ли в нём ошибок, запускайте cargo check: он не тратит время на создание программы. А cargo run — когда хотите увидеть результат.

Первая ошибка компилятора

Rust — строгий учитель: он не запустит программу, пока не найдёт в ней ни одной ошибки. Пугаться этого не нужно, потому что его сообщения подробные. Давайте специально сломаем программу: уберём ! у println.

Rust · main.rs

fn main() {
    println("Копилка 0.1");
}

Запустите cargo check. Вот что увидите:

Ошибка компилятора

error[E0423]: expected function, found macro `println`
 --> src/main.rs:2:5
  |
2 |     println("Копилка 0.1");
  |     ^^^^^^^ not a function
  |
help: use `!` to invoke the macro
  |
2 |     println!("Копилка 0.1");
  |            +

error: could not compile `kopilka` (bin "kopilka") due to 1 previous error

Разбор по строкам

error[E0423]: expected function, found macro `println` — что случилось: ждали функцию, а нашли макрос println. В скобках — номер ошибки: E0423. По нему можно найти подробное объяснение командой rustc --explain E0423.
--> src/main.rs:2:5 — где: файл src/main.rs, строка 2, символ 5. Стрелка --> — то, куда смотреть в первую очередь.
Строка кода с подчёркиванием ^^^^^^^ — Rust показывает само место ошибки.
help: use `!` to invoke the macro — подсказка: «вызывай макрос с !». Плюс под кодом показывает, что именно нужно добавить.
Последняя строка: could not compile — программа не собрана, запускать нечего.

Читайте ошибки сверху вниз: исправили первую — остальные часто исчезают сами. Тот же текст вы увидите прямо в редакторе: rust-analyzer подчёркивает проблемное место красным.

Ещё две типичные ошибки, которые легко сделать самим. Если забыть ; между двумя инструкциями, Rust скажет error: expected `;`, found `println` и в help предложит add `;` here. Если не закрыть кавычку, получите error[E0765]: unterminated double quote string — «незакрытая двойная кавычка».

Практика: проект «Копилка»

Соберём шаг проекта: программа печатает название и подзаголовок.

Откройте терминал, перейдите (командой cd) в папку для проектов и выполните cargo new kopilka, затем cd kopilka.
Откройте папку проекта в редакторе (например, VS Code) и замените содержимое src/main.rs полностью:

Rust · main.rs

// Точка входа программы "Копилка"
fn main() {
    println!("Копилка 0.1");
    println!("Учёт расходов за месяц");
}

Запустите cargo run из папки kopilka. Должно получиться:

Вывод

Копилка 0.1
Учёт расходов за месяц

Выполните cargo check — сообщение Finished без ошибок значит, что код в порядке. Затем cargo build и запустите готовую программу напрямую: ./target/debug/kopilka (Windows: .\target\debug\kopilka.exe).
Сломайте код: уберите ! или закройте не ту кавычку, запустите cargo check, найдите в ответе строку со стрелкой --> и подсказку help, исправьте.

Проверьте себя

Вы можете объяснить, зачем нужен каждый из файлов Cargo.toml и src/main.rs?
Программа печатает ровно две строки, а в начале нет лишних пробелов?
Вы отличаете cargo check (проверка) от cargo run (сборка и запуск)?
Найдёте в тексте ошибки номер строки и подсказку help:?

Частые ошибки

Что видно	Почему	Как исправить
error[E0423]: expected function, found macro `println`	забыли `!`: `println` — макрос	писать `println!(...)`
`error[E0762]: unterminated character literal`	для текста взяли одинарные кавычки: `'...'` — это один символ (`char`)	заменить на двойные: `"..."`
error: could not find `Cargo.toml` in ... or any parent directory	`cargo run` запущен не из папки проекта	выполнить `cd kopilka` и повторить
error: expected `;`	после инструкции не поставили `;`	добавить `;` в конце строки

Что важно запомнить

cargo new имя создаёт готовый проект: Cargo.toml, src/main.rs, .gitignore.
Cargo.toml хранит имя, версию, редакцию (edition = "2024") и зависимости.
Программа начинается с fn main(); println! печатает строку, а ! значит, что это макрос.
Текст пишется в двойных кавычках, инструкция заканчивается ;, комментарий начинается с //.
cargo run собирает и запускает, cargo build только собирает в target/debug, cargo check только проверяет.
В сообщении об ошибке смотрите на error[...], стрелку --> и подсказку help:.

Дальше мы заведём в «Копилке» переменные: лимит месяца и первые траты.

Напечатайте две строки в точности так:

Копилка 0.1
Учёт расходов за месяц

Песочница сама оборачивает ваш код в fn main() { ... }, поэтому пишите только то, что находится внутри main: инструкции println!.