Обновление и удаление
После установки Rust через rustup при выходе новой версии Rust обновление до последней версии не составит труда. В вашем терминале запустите следующий скрипт обновления:
Чтобы удалить Rust и rustup
, выполните следующую команду:
Локальная документация
Установка Rust также включает в себя локальную копию документации, поэтому вы можете читать её в оффлайн режиме. Запустите rustup doc
, чтобы открыть локальную документацию в браузере.
Каждый раз, когда есть какой-либо тип или какая-либо функция, предоставляемые стандартной библиотекой, а вы не знаете, что они делают и как их использовать,
>
echo
%PATH%
>
echo
$env
:Path echo $PATH
$
rustup update
$
rustup self uninstall
воспользуйтесь документацией по интерфейсу прикладного программирования (API) для поиска!
Привет, мир!Итак, когда Rust уже установлен, можно приступать к написанию вашей первой программы. Общая традиция при изучении нового языка программирования - писать маленькую программу, которая печатает в строке вывода "Hello, world!"
. Давайте сделаем то же самое.
Примечание: Эта книга предполагает наличие базового навыка работы с командной строкой. Rust не предъявляет особых требований к тому, каким инструментарием вы пользуетесь для редактирования или хранения вашего кода, поэтому если вы предпочитаете использовать интегрированную среду разработки (IDE) вместо командной строки, смело используйте вашу любимую IDE. Многие IDE сейчас в той или иной степени поддерживают Rust; подробности можно узнать из документации к IDE. Команда Rust сосредоточилась на обеспечении отличной поддержки IDE с помощью rust-analyzer
. Более подробную информацию смотрите в
Приложении
D
!
Создание папки проектаПрежде всего начнём с создания директории, в которой будем сохранять наш код на языке Rust. На самом деле не важно, где сохранять наш код. Однако, для упражнений и проектов, обсуждаемых в данной книге, мы советуем создать директорию
projects в вашем домашнем каталоге, там же и хранить в будущем код программ из книги.
Откройте терминал и введите следующие команды для того,
чтобы создать директориюprojects для хранения кода разных проектов, и, внутри неё, директорию
hello_world для проекта “Hello, world!”.
Для Linux, macOS и PowerShell на Windows, введите:
Для Windows в CMD, введите:
Написание и запуск первой Rust программы$
mkdir /projects
$
cd
/projects
$
mkdir hello_world
$
cd hello_world
> mkdir "%USERPROFILE%\projects"
> cd /d "%USERPROFILE%\projects"
> mkdir hello_world
> cd hello_world
Затем создайте новый исходный файл и назовите его main.rs. Файлы Rust всегда заканчиваются расширением .rs. Если вы используете более одного слова в имени файла,
принято разделять их символом подчёркивания. Например, используйте hello_world.rs
вместо helloworld.rs.
Теперь откроем файл main.rs для редактирования и введём следующие строки кода:
Название файла: main.rs
Листинг 1-1: Программа которая печатает
Hello, world!
Сохраните файл и вернитесь в окно терминала в каталог /projects/hello_world. В Linux или macOS введите следующие команды для компиляции и запуска файла:
В Windows, введите команду
.\main.exe вместо
./main
:
Независимо от операционной системы, строка
Hello, world!
должна напечататься в окне вашего терминала. Если вы не увидели вывода, вернитесь в часть "Решение проблем"
"Troubleshooting"
раздела "Установка" для получения помощи.
Если напечаталось
Hello, world!
, то примите наши поздравления! Вы написали программу на Rust, что делает вас Rust программистом — добро пожаловать!
Анатомия программы на Rust
Давайте рассмотрим «Hello, world!» программу в деталях. Вот первая часть головоломки:
Эти строки определяют функцию с именем main
. Функция main особенная: это всегда первый код, который запускается в каждой исполняемой программе Rust. Первая строка объявляет функцию с именем main
, которая не имеет параметров и ничего не возвращает. Если бы были параметры, они бы заключались в круглые скобки
()
fn main
() { println!
(
"Hello, world!"
);
}
$
rustc main.rs
$
./main
Hello, world!
> rustc main.rs
> .\main.exe
Hello, world! fn main
() {
}
Тело функции заключено в
{}
. Rust требует фигурных скобок вокруг всех тел функций.
Хороший стиль — поместить открывающую фигурную скобку на ту же строку, что и объявление функции, добавив между ними один пробел.
Примечание. Если вы хотите придерживаться стандартного стиля в проектах на
Rust, вы можете использовать инструмент автоматического форматирования под названием rustfmt для форматирования кода в определённом стиле (подробнее о rustfmt в
Приложении D
). ). Команда Rust включила этот инструмент в стандартный дистрибутив Rust, например, rustc
, поэтому он уже должен быть установлен на вашем компьютере!
Тело функции main содержит следующий код:
Эта строка делает всю работу в этой маленькой программе: печатает текст на экран.
Можно заметить четыре важных детали.
Первая, не столь заметная, - в стиле Rust для отступа используются четыре пробела, а не знак табуляции.
Во-вторых, println!
вызывает макрос Rust. Если бы вместо этого была вызвана функция,
она была бы введена как println
(без
!
). Мы обсудим макросы Rust более подробно в
Главе 19. Сейчас вам просто нужно знать, что использование
!
означает, что вы
вызываете макрос вместо обычной функции, и что макросы не всегда следуют тем же правилам, что и функции.
В-третьих, вы видите строку "Hello, world!"
. Мы передаём её в качестве аргумента макросу println!
, и она выводится на экран.
В-четвёртых, мы заканчиваем строку точкой с запятой (
;
), которая указывает на то, что это выражение закончилось и готово начаться следующее. Большинство строк кода на
Rust заканчиваются точкой с запятой.
Компиляция и выполнение кода являются отдельными шагамиВы только что запустили только что созданную программу, так что давайте рассмотрим каждый шаг в этом процессе.
Перед запуском программы на Rust вы должны скомпилировать её с помощью компилятора Rust, введя команду rustc и передав ей имя вашего исходного файла,
например:
println!
(
"Hello, world!"
);
Если у вас есть опыт работы с C или C++, вы заметите, что это похоже на gcc или clang
После успешной компиляции Rust выводит двоичный исполняемый файл.
На Linux, macOS и с PowerShell на Windows вы можете увидеть исполняемый файл, введя команду ls в своём терминале. В Linux и macOS вы увидите два файла. С PowerShell в
Windows вы увидите те же три файла, что и при использовании CMD.
В CMD на Windows следует ввести следующие команды:
Это показывает исходный код файла с расширением .rs, исполняемый файл (main.exe на
Windows, но main на всех других платформах) и, при использовании Windows, файл,
содержащий отладочную информацию с расширением .pdb. Отсюда вы запускаете файлы
main или main.exe, например:
Если ваш main.rs — это ваша программа «Hello, world!», эта строка выведет в терминал
Hello, world!
Если вы лучше знакомы с динамическими языками, такими как Ruby, Python или
JavaScript, возможно, вы не привыкли компилировать и запускать программу как отдельные шаги. Rust — это предварительно скомпилированный язык, то есть вы можете скомпилировать программу и передать исполняемый файл кому-то другому, и он сможет запустить его даже без установленного Rust. Если вы даёте кому-то файл .rb , .py или .js, у него должна быть установлена реализация Ruby, Python или JavaScript (соответственно).
Но в этих языках вам нужна только одна команда для компиляции и запуска вашей программы. В дизайне языков программирования всё — компромисс.
Компиляция с помощью rustc подходит для простых программ, но по мере роста вашего проекта вы захотите управлять всеми параметрами и упростить передачу кода.
Далее мы познакомим вас с инструментом Cargo, который поможет вам писать программы из реального мира на Rust.
$
rustc main.rs
$
ls main main.rs
> dir /B %= the /B option says to only show the file names =% main.exe main.pdb main.rs
$
./main
# для Linux
>
.\main.exe
# для Windows
Привет, Cargo!Cargo - это система сборки и менеджер пакетов Rust. Большая часть разработчиков используют данный инструмент для управления проектами, потому что Cargo
выполняет за вас множество задач, таких как сборка кода, загрузка библиотек, от которых зависит ваш код, и создание этих библиотек. (Мы называем библиотеки, которые нужны вашему коду,
зависимостями.)
Самые простые программы на Rust, подобные той, которую мы написали, не имеют никаких зависимостей. Если бы мы сделали проект «Hello, world!» с Cargo, он бы использовал только ту часть Cargo, которая отвечает за компиляцию вашего кода. По мере написания более сложных программ на Rust вы будете добавлять зависимости, а если вы начнёте проект с использованием Cargo, добавлять зависимости станет намного проще.
Так как большая часть проектов использует Cargo, то остальная часть книги подразумевает, что вы также используете Cargo. Cargo устанавливается вместе с Rust при использовании официальных установщиков обсуждаемых в разделе "Установка Rust"
Если вы установили Rust другим способом, то проверьте, работает ли он, введя команду проверки версии Cargo в терминале:
Если команда выдала номер версии, то значит Cargo установлен. Если вы видите ошибку,
вроде command not found
("команда не найдена"), загляните в документацию для использованного вами способа установки, чтобы выполнить установку Cargo отдельно.
Создание проекта с помощью CargoДавайте создадим новый проект с помощью Cargo и посмотрим, как он отличается от нашего начального проекта "Hello, world!". Перейдите обратно в папку
projects (или любую другую, где вы решили сохранять код). Затем, в любой операционный системе,
запустите команду:
Первая команда создаёт новый каталог и проект с именем
hello_cargo. Мы назвали наш проект
hello_cargo, и Cargo создаёт свои файлы в каталоге с тем же именем.
Перейдём в каталог
hello_cargo и посмотрим файлы. Увидим, что Cargo сгенерировал два файла и одну директорию: файл
Cargo.toml и каталог
src с файлом
main.rs внутри.
Кроме того, cargo инициализировал новый репозиторий Git вместе с файлом
.gitignore.
Файлы Git не будут сгенерированы, если вы запустите cargo new в существующем
$
cargo --version
$
cargo new hello_cargo
$
cd hello_cargo
репозитории Git; вы можете изменить это поведение, используя cargo new --vcs=git
Примечание: Git - это распространённая система контроля версий. Вы можете изменить cargo new на использование другой системы контроля версий или не использовать никакой системы контроля версий с помощью флага
--vcs
Выполните команду cargo new --help
, чтобы увидеть доступные опции.
Откройте файл Cargo.toml в любом текстовом редакторе. Он должен выглядеть как код в листинге 1-2.
Файл: Cargo.toml
Листинг 1-2: Содержимое файла Cargo.toml, сгенерированного командой
cargo new
Это файл в формате
TOML
(Tom’s Obvious, Minimal Language), который является форматом конфигураций Cargo.
Первая строка,
[package]
, является заголовочной секцией, которая указывает что следующие инструкции настраивают пакет. По мере добавления больше информации в данный файл, будет добавляться больше секций и инструкций (строк).
Следующие три строки задают информацию о конфигурации, необходимую Cargo для компиляции вашей программы: имя, версию и редакцию Rust, который будет использоваться. Мы поговорим о ключе edition в
Приложении E
Последняя строка,
[dependencies]
является началом секции для списка любых зависимостей вашего проекта. В Rust, это внешние пакеты кода, на которые ссылаются ключевым словом crate. Нам не нужны никакие зависимости в данном проекте, но мы будем использовать их в первом проекте главы 2, так что нам пригодится данная секция зависимостей потом.
Откройте файл src/main.rs и загляните в него:
Файл : src/main.rs
[package]
name =
"hello_cargo"
version =
"0.1.0"
edition =
"2021"
[dependencies]
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 проектаПосмотрим, в чем разница при сборке и запуске программы "Hello, world!" с помощью
Cargo. В каталоге
hello_cargo соберите проекта следующей командой:
Эта команда создаёт исполняемый файл в
target/debug/hello_cargo (или
target\debug\hello_cargo.exe в Windows), а не в вашем текущем каталоге. Поскольку стандартная сборка является отладочной, Cargo помещает двоичный файл в каталог с именем
debug. Вы можете запустить исполняемый файл с помощью этой команды:
Если все хорошо, то
Hello, world!
печатается в терминале. Запуск команды cargo build в первый раз также приводит к созданию нового файла
Cargo.lock в папке верхнего уровня. Данный файл хранит точные версии зависимостей вашего проекта. Так как у нас нет зависимостей, то файл пустой. Вы никогда не должны менять этот файл вручную:
Cargo сам управляет его содержимым для вас.
Мы только что собрали проект командой cargo build и запустили его из
./target/debug/hello_cargo
. Но мы также можем использовать команду cargo run для компиляции кода и затем его запуска одной командой:
$
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
# or .\target\debug\hello_cargo.exe on Windows
Hello, world!
$
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 также предоставляет команду, называемую cargo check
. Эта команда быстро проверяет ваш код, чтобы убедиться, что он компилируется, но не создаёт исполняемый файл:
Почему вам не нужен исполняемый файл? Часто cargo check
выполняется намного быстрее, чем cargo build
, поскольку пропускает этап создания исполняемого файла.
Если вы постоянно проверяете свою работу во время написания кода, использование cargo check ускорит процесс информирования вас о том, что ваш проект всё ещё
компилируется! Таким образом, многие Rustacean периодически запускают cargo check
,
когда пишут свои программы, чтобы убедиться, что она компилируется. Затем они запускают cargo build
, когда готовы использовать исполняемый файл.
Давайте подытожим, что мы уже узнали о Cargo:
Мы можем создать проект с помощью cargo new можно собирать проект, используя команду cargo build
,
можно одновременно собирать и запускать проект одной командой cargo run
,
можно собрать проект для проверки ошибок с помощью cargo check
, не тратя время на кодогенерацию исполняемого файла,
cargo сохраняет результаты сборки не в директорию с исходным кодом, а в отдельный каталог
target/debug.
Дополнительным преимуществом использования Cargo является то, что его команды одинаковы для разных операционных систем. С этой точки зрения, мы больше не будем предоставлять отдельные инструкции для Linux, macOS или Windows.
$
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 check
Checking hello_cargo v0.1.0 (file:///projects/hello_cargo)
Finished dev [unoptimized + debuginfo] target(s) in 0.32 secs
Сборка финальной версии (Release)Когда проект, наконец, готов к релизу, можно использовать команду cargo build -- release для его компиляции с оптимизацией. Данная команда создаёт исполняемый файл в папке
target/release в отличии от папки
target/debug. Оптимизации делают так, что
Rust код работает быстрее, но их включение увеличивает время компиляции. По этой причине есть два отдельных профиля: один для разработки, когда нужно осуществлять сборку быстро и часто, и другой, для сборки финальной программы, которую будете отдавать пользователям, которая готова к работе и будет выполняться максимально быстро. Если вы
замеряете время выполнения вашего кода, убедитесь, что собрали проект с оптимизацией cargo build --release и тестируете исполняемый файл из папки
target/release.
Скачать 7.02 Mb.