Rust с нуля: cargo new и первая программа

В этом уроке мы начнем Rust с нуля: создадим проект через cargo new, откроем src/main.rs, изменим println!, запустим cargo run и поймем, зачем Rust сразу дает проектную структуру, а не просто один файл

К концу у вас будет рабочий проект, команда запуска и спокойное понимание: где лежит код, что делает Cargo.toml, чем cargo run отличается от cargo build и почему в Rust почти всегда начинают именно с Cargo

Что получится в конце

Создадим проект:

cargo new rust_first
cd rust_first

Откроем файл src/main.rs:

fn main() {
    println!("Hello, Rust!");
}

Запустим:

cargo run

Ожидаемый вывод:

Hello, Rust!

Это не просто Hello World. Это первый нормальный цикл Rust-разработки: создать проект, изменить код, проверить сборку, запустить программу

Что нужно заранее

Нужны терминал, редактор и установленный Rust toolchain. Официальный путь установки — rustup, потому что он ставит и обновляет rustc, cargo и связанные инструменты

Проверьте версии:

rustc --version
cargo --version

Если команды не находятся, перезапустите терминал. Rust обычно добавляет инструменты в ~/.cargo/bin, и shell может увидеть новый PATH только после перезапуска

Для первого знакомства можно использовать Rust Playground, но локальный проект лучше показывает реальность: папка, Cargo.toml, src, сборка, каталог target

Создаем проект через cargo new

Команда:

cargo new rust_first

создает папку проекта. Внутри будет примерно такая структура:

rust_first/
  Cargo.toml
  src/
    main.rs

Cargo.toml описывает пакет: имя, версию, edition и зависимости. src/main.rs хранит код исполняемой программы. Каталог target появится после сборки, его не нужно редактировать руками

Rust можно компилировать и через rustc, но почти все учебные и рабочие проекты идут через Cargo. Так проще подключать зависимости, запускать тесты, собирать релизную версию и держать проект в понятной форме

Первый main.rs

Файл src/main.rs обычно начинается так:

fn main() {
    println!("Hello, world!");
}

fn объявляет функцию. main — точка входа программы. Фигурные скобки ограничивают тело функции

println! выглядит как функция, но восклицательный знак показывает, что это макрос. Для первого урока достаточно знать практический смысл: println! печатает строку и добавляет перевод строки

Измените строку:

println!("Hello, Rust!");

Сохраните файл и запустите cargo run

cargo run, cargo build и cargo check

cargo run собирает проект и запускает готовую программу:

cargo run

cargo build только собирает:

cargo build

После него бинарник появится в target/debug/. Обычно руками туда ходить не нужно, но полезно знать, где лежит результат

cargo check проверяет, компилируется ли код, но не создает полноценный исполняемый файл:

cargo check

Когда проект растет, cargo check часто быстрее, чем полная сборка. Для обучения это хороший способ быстро увидеть ошибки синтаксиса и типов

Изменяем пример под себя

Добавьте переменную:

fn main() {
    let name = "Dinar";
    println!("Hello, {name}!");
}

Rust позволяет вставлять переменную прямо в строку формата через {name}. Это удобно и читается без лишнего шума

Теперь добавьте число:

fn main() {
    let name = "Dinar";
    let lessons = 8;

    println!("Hello, {name}!");
    println!("Rust lessons planned: {lessons}");
}

Проверка:

cargo run

Если вывод изменился, значит вы уже прошли основной путь: код в main.rs меняется, Cargo пересобирает программу, терминал показывает новый результат

Почему Rust сразу строгий

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

Например, если написать:

fn main() {
    let name = "Dinar";
}

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

На первом этапе не нужно бороться с каждым предупреждением как с катастрофой. Но их нужно читать. Rust дает хорошие сообщения, и привычка читать первую ошибку сверху экономит много времени

Мини-практика: команда приветствия

Сделайте программу, которая печатает три строки: имя, язык и следующий шаг:

fn main() {
    let name = "Dinar";
    let language = "Rust";
    let next_step = "ownership";

    println!("Student: {name}");
    println!("Language: {language}");
    println!("Next step: {next_step}");
}

Соберите и запустите:

cargo run

Затем проверьте быстрый режим:

cargo check

Так вы закрепите три команды: создать проект, запустить, проверить. Это фундамент, на котором потом спокойно лягут ownership, Result, коллекции и CLI

Что лежит в Cargo.toml

Откройте Cargo.toml. В первом проекте там обычно есть блок:

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

[dependencies]

name — имя пакета. version — версия вашего проекта. edition — поколение правил Rust, под которое создавался проект. [dependencies] пока пустой, но позже туда будут попадать внешние crates

Новичку не нужно сразу редактировать этот файл. Но важно понимать, что Cargo читает именно его. Если вы запускаете cargo run не в той папке, Cargo ищет Cargo.toml вверх по дереву каталогов и ругается, если не находит

debug и release сборка

Обычный запуск:

cargo run

собирает debug-версию. Она удобна для разработки: быстрее компилируется, содержит отладочную информацию и не пытается выжать максимум производительности

Release-сборка:

cargo build --release

делает оптимизированный бинарник в target/release/. Она компилируется дольше, но обычно работает быстрее. Для первых уроков почти всегда используйте debug-режим, а release держите в голове как отдельный этап перед публикацией или замером скорости

Мини-практика: сломайте пример специально

Хороший способ подружиться с Rust — не только запускать рабочий код, но и читать ошибки. Уберите закрывающую скобку:

fn main() {
    println!("Hello, Rust!");

Запустите:

cargo check

Компилятор покажет, что файл закончился раньше, чем ожидалось. Потом верните скобку и сломайте имя макроса:

printl!("Hello, Rust!");

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

Как держать первый проект чистым

Не редактируйте файлы в target. Это результат сборки, а не исходный код. Не храните учебные заметки внутри src/main.rs, если они не являются кодом. Лучше держать пример коротким, а объяснения — в статье или отдельном markdown-файле

Когда вы переходите к следующему уроку, создавайте новый проект. Так примеры не конфликтуют друг с другом, а ошибки из темы ownership не смешиваются с первым Hello World

Частые ошибки и порядок проверки

cargo: command not found Rust не установлен или терминал не видит ~/.cargo/bin. Проверьте установку через официальный rustup и перезапустите терминал

Запускаете cargo run не в той папке Команду нужно выполнять внутри проекта, где лежит Cargo.toml. Если Cargo пишет, что не нашел manifest, проверьте текущую папку через pwd

Поменяли файл, но вывод старый Убедитесь, что редактируете именно src/main.rs в текущем проекте. В начале обучения легко открыть похожую папку рядом

Пугает слово macro Пока достаточно знать, что println! печатает текст. Макросы Rust разберем позже, когда базовый синтаксис станет привычным

Что может быть еще интересно по этой теме

Rust подходит первым языком? Можно, если вы готовы читать ошибки компилятора и идти не слишком быстро. Но после C, C++, Go или TypeScript многие идеи Rust ложатся понятнее

Нужно ли ставить IDE? Редактор удобен, но первый запуск полезно сделать из терминала. Тогда вы понимаете, что делает Cargo, а не просто нажимаете кнопку Run

Что такое edition в Cargo.toml? Edition задает поколение синтаксических правил Rust. Для новичка важно не менять его вручную без причины

Куда идти после первого запуска? Следующий шаг — ownership и borrowing. Это центральная идея Rust, без нее язык будет казаться странным

Что почитать дальше по Rust

• Ownership и borrowing в Rust простыми словами
• Типы, match, Option и Result в Rust
• Vec, String и HashMap в Rust
• CLI на Rust: мини-проект с аргументами командной строки