Rustprojecten organiseren met pakketten, paden en modules

Roest is een uitstekende keuze voor het bouwen van complexe en betrouwbare toepassingen. Een van de essentiële vaardigheden voor het ontwikkelen van Rust-applicaties is het effectief structureren van uw projecten, inclusief het opnemen van pakketten van derden.

Een goede projectorganisatie is cruciaal voor het ontwikkelen van Rust-toepassingen. Goed gestructureerde Rust-apps verbeteren de samenwerking en eenvoudige app-integraties van derden, waardoor de tijd en moeite die nodig is voor app-ontwikkeling aanzienlijk wordt verminderd. Rust biedt een ingebouwde pakketbeheerder en andere tools voor effectieve codeorganisatie en -beheer.

Roestprojecten opzetten

Het opzetten van Rust-projecten is eenvoudig zodra u Rust op uw machine hebt geïnstalleerd; je kunt Cargo (de ingebouwde pakketbeheerder en het buildsysteem van Rust) gebruiken om een ​​Rust-project te maken en te configureren. Het is vergelijkbaar met andere pakketbeheerders

npm voor Node.js En pip voor Python. Cargo beheert afhankelijkheden, compileert code en genereert documentatie, waardoor het een essentiële tool is voor de ontwikkeling van Rust.

Voer deze opdracht uit om uw Cargo-installatie te verifiëren:

vracht --versie

De opdracht geeft de geïnstalleerde Cargo-versie weer.

U kunt een nieuw Rust-project maken met de lading nieuw commando. U moet de projectnaam opgeven.

vracht nieuw my_project

De opdracht maakt een nieuwe map aan in de huidige map met de basisbestanden die je nodig hebt voor je Rust-project, inclusief een vracht.toml bestand voor het beheren van de afhankelijkheden van uw project.

De naamruimte van het Rust-pakket

Pakketten en kratten zijn essentiële onderdelen in Rust. Crates zijn bibliotheken of binaire bestanden die de Rust-ontwikkelaars kunnen gebruiken en compileren voor een specifiek gebruik, en pakketten zijn een verzameling kratten. Pakketten bevatten meestal een krat met de herbruikbare code en een binair bestand dat een CLI levert voor de bibliotheekkrat.

Kratten moeten de bevatten Cargo.toml bestand met metagegevens over het pakket, zoals de naam, versie, afhankelijkheden en buildscripts.

Rust-pakketten volgen een naamconventie om naamconflicten tussen pakketten te voorkomen. Pakketnamen moeten globaal uniek zijn, kleine letters bevatten en mogen alleen letters, cijfers en koppeltekens bevatten. Als een pakketnaam meerdere woorden bevat, scheidt u deze met koppeltekens, b.v. hyperserver.

Je hebt toegang tot code binnen een naamruimte van een Rust-pakket met de gebruik trefwoord gevolgd door de pakket- en kratnamen.

Hier is een voorbeeld van het importeren van een bel functie van een rand krat:

gebruik rand:: Rng;

U kunt meerdere naamruimten voor pakketten maken. Wanneer u een map maakt, maakt u een nieuwe naamruimte waartoe u toegang hebt met de puntnotatie om het pad naar de identifier op te geven.

In Rust kunnen er meerdere naamruimten voor pakketten zijn. Wanneer u een map maakt, maakt u een nieuwe naamruimte. Om toegang te krijgen tot code uit een andere naamruimte, gebruikt u een puntnotatie om het pad naar de identifier op te geven.

Hier is een voorbeeld van toegang tot een functie vanuit een andere naamruimte:

// bestand in map1 naamruimte
kroegfnmap() -> u32 {
// een functielichaam hier
opbrengst0;
}
// bestand in map2 naamruimte
gebruik map1::map;
kroegfnmap() {
// toegang tot de mapfunctie vanuit de naamruimte folder1
laten folder_func = folder();
}

Het programma definieert twee Rust-modules in verschillende naamruimten, map1 En map2 respectievelijk. De map1 module bevat een publieke functie map die een 32-bits geheel getal zonder teken retourneert.

De map2 module importeert de map functie uit de map1 naamruimte met de gebruik trefwoord, waardoor de map functie om toegang te krijgen tot de map functie uit de map1 moduul. De map functie roept de map functie, en de geretourneerde waarde wordt toegewezen aan de folder_func variabel.

U moet de naam van de ID's van een pakket of krat met een hoofdletter schrijven om ze te exporteren. Wanneer u een identifier exporteert, maakt u deze toegankelijk in andere pakketten die de code gebruiken.

Hier is een voorbeeld van een openbare functie die kan worden geëxporteerd.

// functie geëxporteerd naar andere pakketten en kratten
kroegfnMijnFunctie() {
// een functielichaam hier
}

U moet ook de gebruiken kroeg trefwoord. In Roest, de kroeg trefwoord is een afkorting voor openbaar. Wanneer een functie, struct, enum, elk Rust-gegevenstype of module is gemarkeerd met het trefwoord pub, wordt deze toegankelijk buiten de module. Het item is privé voor zijn module zonder het pub-trefwoord en is alleen toegankelijk vanuit de module.

Modules definiëren om reikwijdte en privacy te regelen

U kunt modules gebruiken om het bereik en de privacy in Rust-programma's te regelen. Met modules kunt u code ordenen in logische eenheden die gemakkelijker te beheren en te onderhouden zijn.

U kunt modules declareren met de mod trefwoord gevolgd door de modulenaam en accolades. Het definiëren van een nieuwe module creëert een nieuwe naamruimte voor de inhoud ervan, wat betekent dat functies, structuren of andere items die binnen de module zijn gedefinieerd, zijn alleen toegankelijk binnen de module, behalve als u expliciet exporteert hen.

Modules helpen naamgevingsconflicten te voorkomen, waardoor code intuïtiever te begrijpen is.

Hier is de syntaxis voor een eenvoudige module:

mod mijn_module {
// module-inhoud komt hier
}

Binnen de module kunt u variabelen, functies, structuren, opsommingen en andere typen definiëren.

mod mijn_module {
fnvoeg_nummers toe(A: i32, B: i32) -> i32 {
 een + b
 }
}

U kunt de kroeg trefwoord om de functie te exporteren en toegang te krijgen tot de functie in andere delen van het programma.

mod mijn_module {
kroegfnvoeg_nummers toe(A: i32, B: i32) -> i32 {
 een + b
 }
}

Nu kunt u bellen met de voeg_nummers toe functie uit andere delen van uw programma.

U kunt ook de privacy van modules regelen met de kroeg trefwoord op moduledefinities.

kroegmod mijn_module {
kroegfnvoeg_nummers toe(A: i32, B: i32) -> i32 {
 een + b
 }
}

Nu de mijn_module module is openbaar en u hebt toegang tot de module vanuit andere modules.

Als u een module of item toegankelijk moet maken voor een specifieke module of set modules, kunt u de kroeg (krat) trefwoord. De kroeg (krat) trefwoord maakt het item toegankelijk vanuit modules in dezelfde krat, maar niet vanuit modules in andere kratten.

mod mijn_module {
kroegstructuurMijnStruct {
kroeg(krat) een_veld: u32,
 }
}

U hebt nu toegang tot het specifieke item (in dit geval de een_veld veld van de MijnStruct struct) in andere delen van uw programma.

fnvoornaamst() {
laten my_struct = my_module:: MyStruct { some_field: 42 };
println!("{}", mijn_structuur.een_veld);
}

De mijn_structuur variabele is een instantie van de MijnStruct structuur. De variabele heeft toegang tot de struct met het padscheidingsteken (::). De voornaamst functie drukt de een_veld veld van de structuur met de println! macro.

Het eigendomsmodel van Rust zorgt voor geheugenveiligheid

Het organiseren van Rust-code is een manier om ervoor te zorgen dat uw code in de loop van de tijd gemakkelijk te onderhouden en te ondersteunen is. Het is gemakkelijker om bugs aan te pakken en de veiligheid te waarborgen in goed georganiseerde code die de regels en conventies van de Rust-community volgt.

Standaard zorgt Rust ervoor dat programma's geheugenveilig zijn met een ingebouwd eigendomsmodel. Het eigendomsmodel zorgt voor geheugenveiligheid door ervoor te zorgen dat variabelen in het geheugen één unieke eigenaar hebben. Het eigendomsmodel voorkomt datasporen en vele soorten geheugenfouten.