Управление организацией в Rust
Любой язык программирования, который не умеет организовывать код, будет трудно освоить; почти ни один программный продукт не компилируется из одного исходного файла.
До этого момента в этом учебнике все программы писались в одном файле, в основном чтобы было удобно изучать синтаксис и концепции Rust.
Для проекта очень важно организовывать код.
В Rust есть три важных организационных понятия: крейт, пакет и модуль.
Крейт
«Крейт» — это двоичный программный файл или файл библиотеки, и он существует в «пакете».
«Крейт» имеет древовидную структуру, а его корнем является программа, скомпилированная из исходного файла, который компилятор компилирует при запуске.
Примечание: «двоичный программный файл» не обязательно является «двоичным исполняемым файлом»; можно лишь утверждать, что это файл, содержащий машинный код целевой платформы, а формат файла зависит от среды компиляции.
Пакет
Когда мы используем Cargo для выполнения команды new, чтобы создать проект Rust, в каталоге проекта создаётся файл Cargo.toml. По сути проект — это пакет. Пакет должен управляться файлом Cargo.toml, который описывает основную информацию о пакете и его зависимости.
Пакет может содержать не более одного библиотечного «крейта», может содержать любое количество двоичных «крейтов», но должен содержать как минимум один «крейт» (будь то библиотечный или двоичный «крейт»).
После создания пакета командой cargo new в каталоге src создаётся исходный файл main.rs. Cargo по умолчанию рассматривает этот файл как корень двоичного крейта, и скомпилированный двоичный крейт будет иметь то же имя, что и пакет.
Модуль
Для программного проекта мы часто организуем его в соответствии с правилами организации используемого языка программирования. Основной структурой для организации модулей часто является дерево. Основной единицей организации функциональных модулей в Java является класс, тогда как JavaScript в основном организует модули через функции.
Организационные единицы этих высокоуровневых языков могут вкладываться слой за слоем, так же как структура каталогов файловой системы. Организационной единицей в Rust является модуль (Module).
mod nation {
mod government {
fn govern() {}
}
mod congress {
fn legislate() {}
}
mod court {
fn judicial() {}
}
}
Это программа, описывающая правовое государство: nation включает government, congress и court, которые выполняют соответственно исполнительную, законодательную и судебную функции. Мы можем преобразовать это в древовидную структуру:
nation ├── government │ └── govern ├── congress │ └── legislate └── court └── judicial
В файловой системе структура каталогов часто использует слеши в строках пути для представления расположения объектов. Разделителем пути в Rust является:: 。
Пути делятся на абсолютные и относительные. Абсолютные пути описываются начиная с ключевого слова crate. Относительные пути описываются начиная с ключевого слова self или super, либо с идентификатора. Например:
crate::nation::government::govern();
является абсолютным путём, описывающим функцию govern. Относительный путь можно выразить так:
nation::government::govern();
Теперь вы можете попробовать определить похожую структуру модулей в исходной программе и использовать пути в функции main.
Если вы сделаете это, вы обязательно обнаружите, что с этим что-то не так: модуль government и функции в нём все приватные, и вам не разрешено обращаться к ним.
Права доступа
В Rust есть два простых права доступа: публичное и приватное.
По умолчанию, если не добавлен модификатор, право доступа для членов модуля будет приватным.
Если вы хотите использовать публичное право доступа, вам нужно использовать ключевое слово pub.
К приватным модулям можно получить доступ только из мест того же уровня или более низких уровней; извне к ним доступа нет.Пример
pub mod government {
pub fn govern() {}
}
mod congress {
pub fn legislate() {}
}
mod court {
fn judicial() {
super::congress::legislate();
}
}
}
fn main() {
nation::government::govern();
}
Эта программа может пройти компиляцию. Пожалуйста, обратите внимание на то, как super используется в модуле court.
Если struct определена в модуле, то помимо того, что сама struct является приватной, её поля по умолчанию также приватны. Следовательно, если вы хотите использовать struct и её поля из модуля, вам нужно объявление pub:
Пример
pub struct Breakfast {
pub toast: String,
seasonal_fruit: String,
}
impl Breakfast {
pub fn summer(toast: &str) -> Breakfast {
Breakfast {
toast: String::from(toast),
seasonal_fruit: String::from("персики"),
}
}
}
}
pub fn eat_at_restaurant() {
let mut meal = back_of_house::Breakfast::summer("Ржаной");
meal.toast = String::from("Пшеничный");
println!("Мне бы хотелось {} тост, пожалуйста", meal.toast);
}
fn main() {
eat_at_restaurant()
}
Вывод:
I'd like Wheat toast please
Варианты enum могут содержать поля, но у них нет аналогичного свойства:
Пример
pub enum Person {
King {
name: String
},
Queen
}
}
fn main() {
let person = SomeModule::Person::King{
name: String::from("Blue")
};
match person {
SomeModule::Person::King {name} => {
println!("{}", name);
}
_ => {}
}
}
Вывод:
Blue
Скрытые модули
Разработчики, пользовавшиеся Java, часто недолюбливают блок самого внешнего класса при программировании — его имя в точности совпадает с именем файла, потому что он представляет контейнер файла. Хотя это и громоздко, нам приходится писать его один раз, чтобы подчеркнуть, что «этот класс — это класс, содержащийся в файле».
Однако у этого есть некоторые преимущества: по крайней мере, это заставляет разработчиков ясно осознавать существование обёртки класса, и это позволяет ясно описать отношения наследования классов.
В Rust модули похожи на обёртки классов в Java, но функцию main можно написать в самом начале файла. Как это объяснить?
Содержимое каждого файла Rust — это "скрытый" модуль.
Давайте покажем это с помощью двух файлов:
файл main.rs
mod second_module;
fn main() {
println!("Это главный модуль.");
println!("{}", second_module::message());
}
файл second_module.rs
pub fn message() -> String {
String::from("Это 2-й модуль.")
}
Вывод:
This is the main module. This is the 2nd module.
Ключевое слово use
Ключевое слово use может вводить идентификаторы модулей в текущую область видимости:
Пример
pub mod government {
pub fn govern() {}
}
}
use crate::nation::government::govern;
fn main() {
govern();
}
Эта программа может пройти компиляцию.
Поскольку ключевое слово use импортирует идентификатор govern в текущий модуль, его можно использовать напрямую.
Это решает проблему слишком длинных путей к локальным модулям.
Конечно, в некоторых случаях есть два одинаковых имени, которые тоже нужно импортировать. Мы можем использовать ключевое слово as, чтобы добавить псевдоним к идентификатору:
Пример
pub mod government {
pub fn govern() {}
}
pub fn govern() {}
}
use crate::nation::government::govern;
use crate::nation::govern as nation_govern;
fn main() {
nation_govern();
govern();
}
Здесь есть две функции govern: одна в nation, а другая в government. Мы используем as, чтобы дать функции в nation псевдоним nation_govern. Оба имени можно использовать одновременно.
Ключевое слово use можно использовать вместе с ключевым словом pub:
Пример
pub mod government {
pub fn govern() {}
}
pub use government::govern;
}
fn main() {
nation::govern();
}
Обращение к стандартной библиотеке
Официальная документация стандартной библиотеки Rust:https://doc.rust-lang.org/stable/std/all.html
После изучения концепций из этой главы мы можем легко импортировать системные библиотеки, чтобы удобно разрабатывать программы:
Пример
fn main() {
println!("{}", (PI / 2.0).sin());
}
Вывод:
1
Все модули системной библиотеки импортируются по умолчанию, поэтому при их использовании вам достаточно применить ключевое слово use, чтобы упростить пути для удобного использования.
Другие расширения