Сочетания клавиш

Нажмите ← или → для навигации между главами

Нажмите S или / для поиска по книге

Нажмите ? для отображения этой справки

Нажмите Esc, чтобы скрыть эту справку

Hello, Cargo!

Cargo — это система сборки и менеджер пакетов Rust. Большинство Rustaceans используют этот инструмент для управления своими проектами на Rust, поскольку Cargo выполняет за вас множество задач, таких как сборка кода, загрузка библиотек, от которых зависит ваш код, и сборка этих библиотек. (Библиотеки, которые нужны вашему коду, мы называем зависимостями.)

Простейшие программы на Rust, как та, что мы написали до сих пор, не имеют зависимостей. Если бы мы собрали проект «Hello, world!» с помощью Cargo, он использовал бы только ту часть Cargo, которая отвечает за сборку кода. По мере написания более сложных программ на Rust вы будете добавлять зависимости, и если начать проект с использованием Cargo, добавлять зависимости будет гораздо проще.

Поскольку подавляющее большинство проектов на Rust используют Cargo, остальная часть этой книги предполагает, что вы тоже используете Cargo. Cargo устанавливается вместе с Rust, если использовались официальные установщики, описанные в разделе «Установка». Если Rust был установлен каким-либо другим способом, проверьте, установлен ли Cargo, введя в терминале следующую команду:

$ cargo --version

Если отображается номер версии — Cargo установлен! Если появляется ошибка, например command not found, обратитесь к документации для вашего способа установки, чтобы определить, как установить Cargo отдельно.

Создание проекта с помощью Cargo

Создадим новый проект с помощью Cargo и посмотрим, чем он отличается от исходного проекта «Hello, world!». Вернитесь в каталог projects (или туда, где вы решили хранить код). Затем в любой операционной системе выполните следующее:

$ cargo new hello_cargo
$ cd hello_cargo

Первая команда создаёт новый каталог и проект с именем hello_cargo. Мы назвали проект hello_cargo, и Cargo создаёт свои файлы в каталоге с тем же именем.

Перейдите в каталог hello_cargo и выведите список файлов. Вы увидите, что Cargo сгенерировал для нас два файла и один каталог: файл Cargo.toml и каталог src с файлом main.rs внутри.

Он также инициализировал новый репозиторий Git вместе с файлом .gitignore. Файлы Git не будут созданы, если запустить cargo new внутри существующего репозитория Git; это поведение можно переопределить с помощью cargo new --vcs=git.

Примечание: Git — распространённая система контроля версий. Можно изменить cargo new, чтобы использовать другую систему контроля версий или не использовать её вовсе, с помощью флага --vcs. Запустите cargo new --help, чтобы увидеть доступные параметры.

Откройте Cargo.toml в любом удобном текстовом редакторе. Он должен выглядеть примерно так, как код в листинге 1-2.

Имя файла: Cargo.toml
[package]
name = "hello_cargo"
version = "0.1.0"
edition = "2024"

[dependencies]
Листинг 1-2: Содержимое Cargo.toml, сгенерированное командой cargo new

Этот файл имеет формат TOML (Tom’s Obvious, Minimal Language), который является форматом конфигурации Cargo.

Первая строка, [package], — это заголовок раздела, указывающий, что следующие операторы настраивают пакет. По мере добавления информации в этот файл мы будем добавлять другие разделы.

Следующие три строки задают информацию о конфигурации, необходимую Cargo для компиляции программы: имя, версию и используемую редакцию Rust. Мы поговорим о ключе edition в Приложении E.

Последняя строка, [dependencies], — это начало раздела для перечисления зависимостей проекта. В Rust пакеты кода называются крейтами. Для этого проекта нам не понадобятся другие крейты, но они понадобятся в первом проекте главы 2, поэтому мы воспользуемся этим разделом зависимостей тогда.

Теперь откройте src/main.rs и взгляните на него:

Имя файла: src/main.rs

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

Cargo сгенерировал для вас программу «Hello, world!», такую же, как та, что мы написали в листинге 1-1! Пока что различия между нашим проектом и проектом, созданным Cargo, заключаются в том, что Cargo поместил код в каталог src, и у нас есть файл конфигурации Cargo.toml в корневом каталоге.

Cargo ожидает, что исходные файлы будут находиться внутри каталога src. Каталог проекта верхнего уровня предназначен только для файлов README, информации о лицензии, файлов конфигурации и всего остального, что не связано с кодом. Использование Cargo помогает организовать проекты. Для всего есть своё место, и всё находится на своём месте.

Если проект был начат без использования Cargo, как мы сделали с проектом «Hello, world!», его можно преобразовать в проект, использующий Cargo. Переместите код проекта в каталог src и создайте соответствующий файл Cargo.toml. Простой способ получить этот файл Cargo.toml — запустить cargo init, который создаст его автоматически.

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

Теперь посмотрим, что изменится при сборке и запуске программы «Hello, world!» с помощью Cargo! Находясь в каталоге hello_cargo, соберите проект, введя следующую команду:

$ cargo build
   Compiling hello_cargo v0.1.0 (file:///projects/hello_cargo)
    Finished dev [unoptimized + debuginfo] target(s) in 2.85 secs

Эта команда создаёт исполняемый файл в target/debug/hello_cargo (или target\debug\hello_cargo.exe в Windows), а не в текущем каталоге. Поскольку сборка по умолчанию является отладочной, Cargo помещает бинарный файл в каталог с именем debug. Запустить исполняемый файл можно командой:

$ ./target/debug/hello_cargo # or .\target\debug\hello_cargo.exe on Windows
Hello, world!

Если всё прошло хорошо, в терминал должно вывестись Hello, world!. Запуск cargo build в первый раз также заставляет Cargo создать новый файл в корневом каталоге: Cargo.lock. Этот файл отслеживает точные версии зависимостей в проекте. В этом проекте нет зависимостей, поэтому файл довольно скудный. Никогда не придётся изменять этот файл вручную; Cargo управляет его содержимым за вас.

Мы только что собрали проект с помощью cargo build и запустили его с помощью ./target/debug/hello_cargo, но можно также использовать cargo run, чтобы скомпилировать код и затем запустить полученный исполняемый файл одной командой:

$ cargo run
    Finished dev [unoptimized + debuginfo] target(s) in 0.0 secs
     Running `target/debug/hello_cargo`
Hello, world!

Использовать cargo run удобнее, чем запоминать, что нужно запустить cargo build, а затем использовать полный путь к бинарному файлу, поэтому большинство разработчиков используют cargo run.

Обратите внимание, что на этот раз мы не увидели вывода о том, что Cargo компилирует hello_cargo. Cargo определил, что файлы не изменились, поэтому он не пересобирал проект, а просто запустил бинарный файл. Если бы исходный код был изменён, Cargo пересобрал бы проект перед запуском, и вы увидели бы такой вывод:

$ cargo run
   Compiling hello_cargo v0.1.0 (file:///projects/hello_cargo)
    Finished dev [unoptimized + debuginfo] target(s) in 0.33 secs
     Running `target/debug/hello_cargo`
Hello, world!

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

$ cargo check
   Checking hello_cargo v0.1.0 (file:///projects/hello_cargo)
    Finished dev [unoptimized + debuginfo] target(s) in 0.32 secs

Почему может не понадобиться исполняемый файл? Часто cargo check работает намного быстрее, чем cargo build, потому что пропускает этап создания исполняемого файла. Если постоянно проверять работу по мере написания кода, использование cargo check ускорит процесс получения информации о том, компилируется ли ещё проект! Поэтому многие Rustaceans периодически запускают cargo check по мере написания программы, чтобы убедиться, что она компилируется. Затем они запускают cargo build, когда готовы использовать исполняемый файл.

Подведём итог тому, что мы узнали о Cargo:

  • Можно создать проект с помощью cargo new.
  • Можно собрать проект с помощью cargo build.
  • Можно собрать и запустить проект за один шаг с помощью cargo run.
  • Можно собрать проект без создания бинарного файла для проверки ошибок с помощью cargo check.
  • Вместо сохранения результата сборки в том же каталоге, что и код, Cargo сохраняет его в каталоге target/debug.

Дополнительное преимущество использования Cargo заключается в том, что команды одинаковы независимо от операционной системы. Поэтому с этого момента мы больше не будем приводить отдельные инструкции для Linux и macOS и для Windows.

Сборка для релиза

Когда проект наконец готов к выпуску, можно использовать cargo build --release, чтобы скомпилировать его с оптимизациями. Эта команда создаст исполняемый файл в target/release вместо target/debug. Оптимизации заставляют код на Rust работать быстрее, но их включение увеличивает время компиляции программы. Именно поэтому существуют два разных профиля: один для разработки, когда нужно быстро и часто пересобирать проект, и другой для сборки финальной программы, которую вы передадите пользователю, которая не будет пересобираться многократно и будет работать как можно быстрее. Если проводится бенчмаркинг времени выполнения кода, обязательно запустите cargo build --release и выполняйте бенчмарк с исполняемым файлом в target/release.

Использование соглашений Cargo

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

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

$ git clone example.org/someproject
$ cd someproject
$ cargo build

Дополнительную информацию о Cargo см. в его документации.

Итоги

Вы уже отлично начали свой путь в Rust! В этой главе вы узнали, как:

  • Установить последнюю стабильную версию Rust с помощью rustup.
  • Обновиться до более новой версии Rust.
  • Открыть локально установленную документацию.
  • Написать и запустить программу «Hello, world!» напрямую с помощью rustc.
  • Создать и запустить новый проект, используя соглашения Cargo.

Это отличное время, чтобы создать более существенную программу и привыкнуть читать и писать код на Rust. Поэтому в главе 2 мы создадим программу-угадайку. Если же вы предпочитаете начать с изучения того, как работают распространённые концепции программирования в Rust, см. Главу 3, а затем вернитесь к главе 2.