Убедитесь, что ваши проекты Rust хорошо организованы, чтобы их было легче поддерживать с течением времени.

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

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

Настройка проектов Rust

Настраивать проекты Rust легко как только вы установили Rust на свой компьютер; вы можете использовать Cargo (встроенный менеджер пакетов и система сборки Rust) для создания и настройки проекта Rust. Он похож на другие менеджеры пакетов, такие как npm для Node.js

instagram viewer
и пип для питона. Cargo управляет зависимостями, компилирует код и генерирует документацию, что делает его незаменимым инструментом для разработки на Rust.

Запустите эту команду, чтобы проверить установку Cargo:

груз --версия

Команда отображает установленную версию Cargo.

Вы можете создать новый проект Rust с помощью груз новый команда. Вам нужно указать имя проекта.

груз новый my_project

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

Пространство имен пакетов Rust

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

Ящики должны содержать Груз.томл файл, содержащий метаданные о пакете, такие как его имя, версия, зависимости и скрипты сборки.

Пакеты Rust следуют соглашению об именах, чтобы избежать конфликтов имен между пакетами. Имена пакетов должны быть глобально уникальными, строчными и содержать только буквы, цифры и дефисы. Если имя пакета содержит несколько слов, разделите их дефисом, например. гиперсервер.

Вы можете получить доступ к коду в пространстве имен пакетов Rust с помощью использовать ключевое слово, за которым следуют имена пакетов и ящиков.

Вот пример импорта Кольцо функция от ранд ящик:

использовать ранд:: Rng;

Вы можете создать несколько пространств имен для пакетов. Когда вы создаете папку, вы создаете новое пространство имен, доступ к которому можно получить с помощью записи через точку, чтобы указать путь к идентификатору.

В Rust может быть несколько пространств имен для пакетов. Когда вы создаете папку, вы создаете новое пространство имен. Чтобы получить доступ к коду из другого пространства имен, вы используете запись через точку, чтобы указать путь к идентификатору.

Вот пример доступа к функции из другого пространства имен:

// файл в пространстве имен folder1
пабфнпапка() -> U32 {
// здесь какое-то тело функции
возвращаться0;
}
// файл в пространстве имен folder2
использовать папка1::папка;
пабфнкаталог() {
// доступ к функции папки из пространства имен folder1
позволять folder_func = папка();
}

Программа определяет два модуля Rust в разных пространствах имен, папка1 и папка2 соответственно. папка1 модуль содержит публичную функцию папка который возвращает 32-битное целое число без знака.

папка2 модуль импортирует папка функцию от папка1 пространство имен с использовать ключевое слово, позволяющее каталог функция для доступа к папка функцию от папка1 модуль. каталог функция вызывает папка функция, а возвращаемое значение присваивается folder_func переменная.

Вам нужно будет использовать заглавные буквы в именах идентификаторов из пакета или ящика, чтобы экспортировать их. Когда вы экспортируете идентификатор, вы делаете его доступным в других пакетах, использующих этот код.

Вот пример общедоступной функции, которую можно экспортировать.

// функция экспортируется в другие пакеты и крейты
пабфнМояФункция() {
// здесь какое-то тело функции
}

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

Определение модулей для управления областью действия и конфиденциальностью

Вы можете использовать модули для управления областью действия и конфиденциальностью в программах на Rust. Модули позволяют организовать код в логические блоки, которыми легче управлять и поддерживать.

Вы можете объявить модули с помощью мод ключевое слово, за которым следует имя модуля и фигурные скобки. При определении нового модуля создается новое пространство имен для его содержимого, что означает, что функции, структуры или другие элементы, определенные в модуле, доступны только внутри модуля, за исключением явного экспорта их.

Модули помогают предотвратить конфликты имен, делая код более понятным для понимания.

Вот синтаксис простого модуля:

мод мой_модуль {
// здесь содержимое модуля
}

В модуле вы можете определять переменные, функции, структуры, перечисления и другие типы.

мод мой_модуль {
фнadd_numbers(а: i32, б: i32) -> i32 {
 а + б
 }
}

Вы можете использовать паб ключевое слово для экспорта функции и доступа к ней в других частях программы.

мод мой_модуль {
пабфнadd_numbers(а: i32, б: i32) -> i32 {
 а + б
 }
}

Теперь вы можете позвонить в add_numbers функции из других частей вашей программы.

Вы также можете контролировать конфиденциальность модулей с помощью паб ключевое слово в определениях модулей.

пабмод мой_модуль {
пабфнadd_numbers(а: i32, б: i32) -> i32 {
 а + б
 }
}

Сейчас мой_модуль модуль является общедоступным, и вы можете получить доступ к модулю из других модулей.

Если вам нужно сделать модуль или элемент доступным для определенного модуля или набора модулей, вы можете использовать паб (ящик) ключевое слово. паб (ящик) ключевое слово делает элемент доступным из модулей в том же ящике, но не из модулей в других ящиках.

мод мой_модуль {
пабструктураМояСтруктура {
паб(ящик) некоторое_поле: U32,
 }
}

Теперь вы можете получить доступ к конкретному элементу (в данном случае некоторое_поле поле МояСтруктура struct) в других частях вашей программы.

фносновной() {
позволять my_struct = my_module:: MyStruct { some_field: 42 };
распечатать!("{}", my_struct.some_field);
}

моя_структура переменная является экземпляром МояСтруктура структура. Переменная обращается к структуре с разделителем пути (::). основной функция печатает некоторое_поле поле структуры с распечатать! макрос.

Модель владения Rust обеспечивает безопасность памяти

Организация кода Rust — это один из способов сделать ваш код простым в сопровождении и поддержке с течением времени. Легче устранять ошибки и обеспечивать безопасность в хорошо организованном коде, соответствующем правилам и соглашениям сообщества Rust.

По умолчанию Rust обеспечивает безопасность программ в памяти с помощью встроенной модели владения. Модель владения обеспечивает безопасность памяти, гарантируя, что переменные в памяти имеют одного уникального владельца. Модель владения предотвращает трассировку данных и многие типы ошибок памяти.