ВВЕДЕНИЕ
Какие имена реализует компилятор в этом месте кода?
Какие функции мне разрешено вызывать? К чему относится эта переменная?
Модульная система охватывает
Пакеты — это функция Cargo, которая позволяет нам создавать, тестировать и делиться ящиками.
Ящики — это дерево модулей, которые создают библиотеку или исполняемый файл.
Модули и, следовательно, ключевое слово use позволяют нам контролировать объем и конфиденциальность путей.
Путь может быть способом именования элемента, например структуры, функции или модуля.
ПАКЕТЫ И ЯЩИКИ для создания БИБЛИОТЕКИ И ИСПОЛНЯЕМЫХ ПРОГРАММ:
Крейт может быть двоичным файлом или библиотекой.
Корень крейта может быть исходным файлом, который используется для создания крейта.
Пакет содержит Cargo.toml, который описывает способ сборки одного или больше ящиков. не более одного ящика во время пакета часто являются библиотекой.
Пример пакета:
$ cargo new my-project
Создан двоичный файл (приложение) ` пакет my-project`
$ ls my-project
Cargo.toml
src
$ ls my-project/src
main.rs
МОДУЛЬНАЯ СИСТЕМА для регулирования СФЕРЫ И КОНФИДЕНЦИАЛЬНОСТИ:
Особенности:
1. Модули, как упорядочивать код и контролировать конфиденциальность путей
2. Пути, как вызывать элементы
3. Ключевое слово, используемое для включения пути в область действия
> 4. pub, ключевое слово для формирования элементов public
5. Переименование элементов при включении их в область действия с помощью ключевого слова as
6. Использование внешних пакетов
7. Вложенные пути для устранения большого использования списки
8. Использование оператора glob для переноса всего во время модуля в область видимости
9. Способ разделения модулей на отдельные файлы
МОДУЛИ:
Модули позволяют группировать код.
Пример:
mod sound {
fn Guitar() {
// Здесь находится код тела функции
}
}
fn main() {
}
МОДУЛИ (ВКЛАДНЫЕ):
мод звук {
мод инструмент {
mod woodwind {
fn clarinet() {
// Здесь находится код тела функции
}
}
}
mod voice {
}
}
fn main() {
}
Иерархия
ящик
└── звук
├── инструмент
│ └── духовые
└── голос
ДЕРЕВО МОДУЛЯ VS ФАЙЛОВАЯ СИСТЕМА:
Это дерево может напомнить вам дерево каталогов файловой системы на нашем компьютере. Это немного похоже на каталоги в файловой системе: вы размещаете код внутри любого модуля, который создаст желаемую организацию. Другое сходство заключается в том, что для запроса элемента в файловой системе или дереве модулей мы используем его путь.
ПУТИ:
Если мы хотим вызвать функцию, мы хотели бы понять ее путь. Путь может принимать две формы: Абсолютный путь начинается с корня ящика, используя имя ящика или буквальное «ящик». Относительный путь начинается с текущего модуля и использует «я», «супер» или идентификатор в текущем модуле. За абсолютным и относительным путями следует один или несколько идентификаторов, разделенных двойным двоеточием (::).
ПУТИ (ПРИМЕР):
мод звук {
мод инструмент {
fn clarinet() {
// Здесь находится код тела функции
}
}
}
fn main() {
// Абсолютный путь
crate::sound::instrument::clarinet();
/ / Относительный путь
sound::instrument::clarinet();
}
МОДУЛИ КАК ГРАНИЦА КОНФИДЕНЦИАЛЬНОСТИ:
Модули используются для организации
Модули также используются для границы конфиденциальности в Rust.
Правила конфиденциальности:
○ Все элементы (функции, методы, структуры, перечисления, модули и константы) по умолчанию являются закрытыми.
○ мы будем использовать ключевое слово pub, чтобы сделать элемент общедоступным.
○ Нам не разрешено использовать закрытый код, определенный в модулях, которые являются дочерними элементами текущего модуля.
○ Нам разрешено использовать любой код, определенный в модулях-предках или в текущем модуле.
ПУТИ (ПРИМЕР С PUB):
mod sound {
pub mod tools {
pub fn clarinet() {
// Здесь находится код тела функции
}
}
}
fn main() {
// Абсолютный путь
crate::sound::instrument::clarinet();< br /> // Относительный путь
sound::instrument::clarinet();
}
НАЧАЛО ОТНОСИТЕЛЬНЫХ ПУТЕЙ С
fn
main() {} :
SUPER
mod Instrument {
fn clarinet() {
super::breathe_in();
}
}
fn breath_in() {
// Здесь находится код тела функции
}
ИСПОЛЬЗОВАНИЕ PUB СО СТРУКТУРАМИ:
mod plant {
pub struct Vegetable {
pub name: String,
id: i32,
}
impl Vegetable {
pub fn new(name: &str) -> Овощной
{
Овощной {
name: String::from(name),
id: 1,
}
}
}
}
fn main() {
let mut v =
plant::Vegetable::new(“сквош”);
v.name = String::from("мускатная тыква");
println!("{} вкусные", v.name);
// println!("ID: {}", v.id );
}
ИСПОЛЬЗОВАНИЕ PUB С ПЕРЕЧИСЛЕНИЯМИ:
mod menu {
pub enum Закуска {
Суп,
Салат,
}
}
fn main() {
let order1 = меню ::Закуска::Суп;
let order2 = menu::Закуска::Салат;
}
КЛЮЧЕВОЕ СЛОВО «ИСПОЛЬЗУЙТЕ» ДЛЯ ПРИВЕДЕНИЯ АБСОЛЮТНЫХ ПУТЕЙ В ОБЛАСТЬ:
mod sound {
pub mod tools {
pub fn clarinet() {
// Здесь находится код тела функции
}
}
}
используйте crate::sound::instrument;
fn main() {
Instrument:: clarinet();
Instrument:: clarinet (); );
}
КЛЮЧЕВОЕ СЛОВО «USE» ДЛЯ ПРИВЕДЕНИЯ ОТНОСИТЕЛЬНЫХ ПУТЕЙ В ОБЛАСТЬ:
mod sound {
pub mod tools {
pub fn clarinet() {
// Здесь находится код тела функции
}
}
}
использовать self::sound::instrument;
fn main() {
Instrument:: clarinet();
Instrument:: clarinet(); );
}
АБСОЛЮТНЫЙ ПРОТИВ ОТНОСИТЕЛЬНЫХ ПУТЕЙ С «ИСПОЛЬЗОВАНИЕМ»:
mod sound {
pub mod tools {
pub fn clarinet() {
// Здесь находится код тела функции
}}}
mod performance_group {
используйте crate::sound::instrument;
pub fn clarinet_trio() {
Instrument::clarinet();
Instrument:: clarinet();
Instrument:: clarinet ( );
}}
fn main() {
performance_group::clarinet_trio();
}
Идиоматическое использование путей для функций
mod sound {
pub mod tools {
pub fn clarinet() {
// Здесь находится код тела функции
}
}
}
используйте crate::sound::instrument::clarinet;
fn main() {
clarinet();
clarinet();
clarinet();
}
Идиоматическое использование путей для структур/перечислений и других элементов
используйте std::collections::HashMap;
fn main() {
let mut map = HashMap::new();
map.insert(1, 2);
}
Исключением из настоящей идиомы является то, что если бы операторы использования «принесли бы два элемента с эквивалентным именем в область действия, что не разрешено.
используйте std::fmt; используйте std::io;
fn function1() -> fmt::Result {}
fn function2() -> io::Result {}
у нас может быть два типа Result в та же область видимости, и Rust не узнает, какую из них мы имели в виду, как только мы использовали Result.
Приведено в действие с помощью ключевого слова as для переименования типов
Мы приведем два сорта с эквивалентным именем в эквивалентную область.
Мы укажем замещающее локальное имя для сорта, добавив «as» и заменяющее имя после «use»
Пример:
использовать std::fmt::Result;
использовать std::io::Result как IoResult;
fn function1() -> Result { }
fn function2() -> IoResult { }
Повторный экспорт имен с использованием pub
Как только мы вводим репутацию в область действия с помощью ключевого слова использования, имя, доступное в новой области действия, становится приватным. Если мы хотим, чтобы код, вызывающий наш код, был готов запрашивать сортировку, как если бы она была определена в его области, даже как это делает наш код, мы будем комбинировать pub и use. Эта система называется реэкспортом, потому что мы приносим элемент в область действия, но также сделать этот элемент доступным для других, чтобы они могли внести в свою область.
Реэкспорт имен с использованием pub (пример)
mod sound {
pub mod Instrument {
pub fn clarinet() {
// Здесь находится код тела функции
} } }
mod performance_group {
pub use crate::sound::instrument;
pub fn clarinet_trio() {
Instrument::clarinet();
Instrument::clarinet();
Instrument::clarinet ();
} }
fn main() { performance_group::clarinet_trio();
performance_group::instrument::clarinet(); }
Использование внешних пакетов
Члены сообщества опубликовали множество пакетов на https://crates.io.
Добавление любого из них в наш пакет включает следующие шаги:
○ перечисление их в нашем пакете Cargo.toml
○ добавление элементов, определенных в них, в область действия в нашем пакете с использованием.
Пример: Пакет «rand» часто загружается со следующим кодом в
Файл Cargo.toml:
[зависимости]
rand = «0.5.5»
Вложенные пути для очистки больших списков использования
Как только мы используем много элементов, определенных в эквивалентном пакете или в одном модуле, перечисление каждого элемента в отдельной строке может занять тонны вертикального пространства в наших файлах.
Например, эти два оператора использования переносят элементы из стандартного сфера:
использовать std::cmp::Ordering;
использовать std::io;
мы будем использовать вложенные пути, чтобы представить эквивалентные элементы в одной строке, а не в двух, как:
используйте std::{cmp::Ordering, io};
С оператором Glob, объединяющим все общедоступные определения в область видимости
Чтобы включить в область действия все общедоступные элементы, определенные во время пути, вы должны указать этот путь, за которым следует *, оператор glob
use std::collections::*;
Обычно оператор glob используется, когда тестирование, чтобы привести все тестируемое в модуль тестов. Оператор glob дополнительно иногда используется как часть шаблона прелюдии.
Разделение модулей на разные файлы
До сих пор мы определяли несколько модулей в одном файле.
Когда модули становятся большими, вам нужно перемещать их определения в отдельный файл, чтобы сформировать код, в котором легче ориентироваться.
mod sound;
fn main() {
// Абсолютный путь
crate::sound::instrument::clarinet();
// Относительный путь
sound ::инструмент::кларнет();
}
Файл src/sound.rs:
pub mod Instrument {
pub fn clarinet() {
// Здесь находится код тела функции
}
}
Дерево модулей остается эквивалентным, и поэтому вызовы функций в main по-прежнему работают без изменений, хотя определения спят в разных файлах. Это позволяет перемещать модули в новые файлы по мере их увеличения.
Для получения более подробной информации посетите: https://www.technologiesinindustry4.com/2020/11/what-are-packagescrates-and-modules-in-rust.html
