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

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

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

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

Настройването на Rust проекти е лесно след като инсталирате Rust на вашата машина; можете да използвате Cargo (вграден мениджър на пакети и система за изграждане на Rust), за да създадете и конфигурирате проект на Rust. Той е подобен на други мениджъри на пакети като

instagram viewer
npm за Node.js и pip за Python. Cargo управлява зависимости, компилира код и генерира документация, което го прави основен инструмент за разработката на Rust.

Изпълнете тази команда, за да проверите инсталацията на Cargo:

карго --версия

Командата показва инсталираната версия на Cargo.

Можете да създадете нов проект на Rust с товар нов команда. Ще трябва да посочите името на проекта.

карго нов my_project

Командата ще създаде нова директория в текущата директория, съдържаща основните файлове, от които се нуждаете за вашия проект Rust, включително cargo.toml файл за управление на зависимостите на вашия проект.

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

Пакетите и касите са основни компоненти в Rust. Сандъците са библиотеки или двоични файлове, които разработчиците на Rust могат да използват и компилират за някаква конкретна употреба, а пакетите са колекция от каси. Пакетите обикновено съдържат кутия, която съдържа кода за многократна употреба и двоичен файл, който предоставя CLI за кутията на библиотеката.

Касите трябва да съдържат Cargo.toml файл, съдържащ метаданни за пакета, като неговото име, версия, зависимости и скриптове за компилация.

Пакетите Rust следват конвенция за именуване, за да се избегнат конфликти в именуване между пакетите. Имената на пакетите трябва да са глобално уникални, с малки букви и да съдържат само букви, цифри и тирета. Ако името на пакет съдържа няколко думи, разделете ги с тирета, напр. хипер-сървър.

Можете да получите достъп до кода в пространството на имената на пакета Rust с използване ключова дума, последвана от имената на пакета и кашона.

Ето пример за импортиране на Rng функция от a ранд щайга:

използване ранд:: Rng;

Можете да създадете множество пространства от имена за пакети. Когато създавате папка, вие създавате ново пространство от имена, до което можете да получите достъп с нотацията с точка, за да посочите пътя до идентификатора.

В Rust може да има множество пространства от имена за пакети. Когато създавате папка, създавате ново пространство от имена. За достъп до код от друго пространство от имена, вие използвате нотация с точка, за да посочите пътя до идентификатора.

Ето пример за достъп до функция от различно пространство от имена:

// файл в пространство от имена на folder1
кръчмаfnпапка() -> u32 {
// някакво тяло на функция тук
връщане0;
}
// файл в пространство от имена на folder2
използване folder1::папка;
кръчмаfnуказател() {
// достъп до функцията за папка от пространството от имена folder1
позволявам folder_func = folder();
}

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

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

Ще трябва да изпишете с главни букви името на идентификаторите от пакет или кашон, за да ги експортирате. Когато експортирате идентификатор, вие го правите достъпен в други пакети, които използват кода.

Ето пример за публична функция, която може да бъде експортирана.

// функция, експортирана в други пакети и каси
кръчмаfnMyFunction() {
// някакво тяло на функция тук
}

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

Дефиниране на модули за контрол на обхвата и поверителността

Можете да използвате модули, за да контролирате обхвата и поверителността в програмите Rust. Модулите ви позволяват да организирате кода в логически единици, които са по-лесни за управление и поддръжка.

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

Модулите помагат за предотвратяване на конфликти при именуване, правейки кода по-интуитивен за разбиране.

Ето синтаксиса за прост модул:

мод my_module {
// съдържанието на модула отива тук
}

В рамките на модула можете да дефинирате променливи, функции, структури, enums и други типове.

мод my_module {
fnдобавяне на числа(а: i32, b: i32) -> i32 {
 a + b
 }
}

Можете да използвате кръчма ключова дума за експортиране на функцията и достъп до функцията в други части на програмата.

мод my_module {
кръчмаfnдобавяне на числа(а: i32, b: i32) -> i32 {
 a + b
 }
}

Сега можете да се обадите на добавяне на числа функция от други части на вашата програма.

Можете също да контролирате поверителността на модулите с кръчма ключова дума в дефинициите на модула.

кръчмамод my_module {
кръчмаfnдобавяне на числа(а: i32, b: i32) -> i32 {
 a + b
 }
}

Сега, на моят_модул модулът е публичен и можете да получите достъп до него от други модули.

Ако трябва да направите модул или елемент достъпен за конкретен модул или набор от модули, можете да използвате кръчма (щайга) ключова дума. The кръчма (щайга) ключова дума прави артикула достъпен от модули в една и съща каса, но не и от модули в други каси.

мод my_module {
кръчмаструктураMyStruct {
кръчма(щайга) някое_поле: u32,
 }
}

Вече можете да получите достъп до конкретния елемент (в този случай до някое_поле поле на MyStruct struct) в други части на вашата програма.

fnосновен() {
позволявам my_struct = my_module:: MyStruct { some_field: 42 };
println!("{}", my_struct.some_field);
}

The моята_структура променливата е екземпляр на MyStruct структура Променливата има достъп до структурата с разделителя на пътя (::). The основен функция отпечатва някое_поле поле на структурата с println! макрос.

Моделът на собственост на Rust гарантира безопасност на паметта

Организирането на Rust код е един от начините да гарантирате, че вашият код е лесен за поддръжка и поддръжка във времето. По-лесно е да се справяте с грешки и да гарантирате безопасност в добре организиран код, който следва правилата и конвенциите на общността на Rust.

По подразбиране Rust гарантира, че програмите са безопасни за паметта с вграден модел на собственост. Моделът на собственост гарантира безопасността на паметта, като гарантира, че променливите в паметта имат един уникален собственик. Моделът на собственост предотвратява проследяване на данни и много видове грешки в паметта.