Organisering af rustprojekter med pakker, stier og moduler

Rust er et fremragende valg til at bygge komplekse og pålidelige applikationer. En af de essentielle færdigheder til at udvikle Rust-applikationer er at strukturere dine projekter effektivt, herunder at inkorporere tredjepartspakker.

Effektiv projektorganisering er afgørende for udvikling af Rust-applikationer. Velstrukturerede Rust-apps forbedrer samarbejdet og nemme tredjeparts-app-integrationer, hvilket reducerer den tid og indsats, der kræves til app-udvikling. Rust leverer en indbygget pakkehåndtering og andre værktøjer til effektiv kodeorganisering og -styring.

Opsætning af rustprojekter

Det er nemt at opsætte Rust-projekter når du har installeret Rust på din maskine; du kan bruge Cargo (Rusts indbyggede pakkehåndtering og byggesystem) til at oprette og konfigurere et Rust-projekt. Det ligner andre pakkeadministratorer som npm for Node.js og pip til Python. Cargo administrerer afhængigheder, kompilerer kode og genererer dokumentation, hvilket gør det til et vigtigt værktøj til Rust-udvikling.

Kør denne kommando for at bekræfte din Cargo-installation:

last --version

Kommandoen viser den installerede Cargo-version.

Du kan oprette et nyt Rust-projekt med last ny kommando. Du skal angive projektets navn.

last nyt mit_projekt

Kommandoen vil oprette en ny mappe i den aktuelle mappe, der indeholder de grundlæggende filer, du har brug for til dit Rust-projekt, inklusive en cargo.toml fil til styring af dit projekts afhængigheder.

Rustpakkens navneområde

Pakninger og kasser er væsentlige komponenter i Rust. Kasser er biblioteker eller binære filer, som Rust-udviklerne kan bruge og kompilere til en bestemt brug, og pakker er en samling af kasser. Pakker indeholder normalt en kasse, der indeholder den genanvendelige kode, og en binær, der giver en CLI til bibliotekskassen.

Kasserne skal indeholde Cargo.toml fil, der indeholder metadata om pakken, såsom dens navn, version, afhængigheder og build-scripts.

Rustpakker følger en navnekonvention for at undgå navnekonflikter mellem pakker. Pakkenavne skal være globalt unikke, små bogstaver og kun indeholde bogstaver, cifre og bindestreger. Hvis et pakkenavn indeholder flere ord, skal du adskille dem med bindestreger, f.eks. hyper-server.

Du kan få adgang til kode i et Rust-pakkenavneområde med brug søgeord efterfulgt af pakke- og kassenavne.

Her er et eksempel på import af en Rng funktion fra en rand kasse:

brug rand:: Rng;

Du kan oprette flere navnerum til pakker. Når du opretter en mappe, opretter du et nyt navneområde, som du kan få adgang til med priknotationen for at angive stien til identifikatoren.

I Rust kan der være flere navnerum til pakker. Når du opretter en mappe, opretter du et nyt navneområde. For at få adgang til kode fra et andet navneområde bruger du en priknotation til at angive stien til identifikatoren.

Her er et eksempel på adgang til en funktion fra et andet navneområde:

// fil i mappe1 navneområde
pubfnfolder() -> u32 {
// noget funktionslegeme her
Vend tilbage0;
}
// fil i mappe2 navneområde
brug mappe1::mappe;
pubfnvejviser() {
// adgang til mappefunktionen fra mappe1-navnerummet
lade folder_func = mappe();
}

Programmet definerer to Rust-moduler i forskellige navnerum, mappe 1 og mappe 2 henholdsvis. Det mappe 1 modul indeholder en offentlig funktion folder der returnerer en 32-bit heltalsværdi uden fortegn.

Det mappe 2 modul importerer folder funktion fra mappe 1 navneområde med brug søgeord, der tillader vejviser funktion for at få adgang til folder funktion fra mappe 1 modul. Det vejviser funktionen kalder folder funktion, og returværdien tildeles til folder_func variabel.

Du skal skrive navnet på identifikatorerne fra en pakke eller kasse med stort for at eksportere dem. Når du eksporterer en identifikator, gør du den tilgængelig i andre pakker, der bruger koden.

Her er et eksempel på en offentlig funktion, der kan eksporteres.

// funktion eksporteret til andre pakker og kasser
pubfnMyFunction() {
// noget funktionslegeme her
}

Du skal også bruge pub søgeord. I Rust, den pub søgeord er en forkortelse for offentlig. Når en funktion, struktur, enum, enhver rustdatatype eller modul er markeret med pubnøgleordet, bliver det tilgængeligt uden for dets modul. Elementet er privat for dets modul uden pubnøgleordet og kan kun tilgås inde fra det.

Definition af moduler til at kontrollere omfang og privatliv

Du kan bruge moduler til at kontrollere omfang og privatliv i Rust-programmer. Moduler giver dig mulighed for at organisere kode i logiske enheder, der er nemmere at administrere og vedligeholde.

Du kan erklære moduler med mod nøgleord efterfulgt af modulnavn og krøllede seler. Definering af et nyt modul opretter et nyt navneområde for dets indhold, hvilket betyder, at funktioner, strukturer eller andre elementer, der er defineret i modulet, er kun tilgængelige i modulet, undtagen at du eksplicit eksporterer dem.

Moduler hjælper med at forhindre navnekonflikter, hvilket gør koden mere intuitiv at forstå.

Her er syntaksen for et simpelt modul:

mod mit_modul {
// modulindhold se her
}

Inden for modulet kan du definere variabler, funktioner, strukturer, enums og andre typer.

mod mit_modul {
fntilføje_numre(en: i32, b: i32) -> i32 {
 a + b
 }
}

Du kan bruge pub nøgleord for at eksportere funktionen og få adgang til funktionen i andre dele af programmet.

mod mit_modul {
pubfntilføje_numre(en: i32, b: i32) -> i32 {
 a + b
 }
}

Nu kan du ringe til tilføje_numre funktion fra andre dele af dit program.

Du kan også styre fortroligheden af ​​moduler med pub nøgleord om moduldefinitioner.

pubmod mit_modul {
pubfntilføje_numre(en: i32, b: i32) -> i32 {
 a + b
 }
}

Nu, den mit_modul modulet er offentligt, og du kan få adgang til modulet fra andre moduler.

Hvis du skal gøre et modul eller element tilgængeligt for et bestemt modul eller sæt af moduler, kan du bruge pub (kasse) søgeord. Det pub (kasse) søgeord gør varen tilgængelig fra moduler i samme kasse, men ikke fra moduler i andre kasser.

mod mit_modul {
pubstrukturMyStruct {
pub(kasse) some_field: u32,
 }
}

Du kan nu få adgang til det specifikke element (i dette tilfælde noget_felt felt af MyStruct struct) i andre dele af dit program.

fnvigtigste() {
lade my_struct = my_module:: MyStruct { some_field: 42 };
println!("{}", my_struct.some_field);
}

Det min_struktur variabel er en forekomst af MyStruct struktur. Variablen får adgang til strukturen med sti-separatoren (::). Det vigtigste funktion udskriver noget_felt felt af strukturen med println! makro.

Rusts ejerskabsmodel sikrer hukommelsessikkerhed

Organisering af rustkode er en måde at sikre, at din kode er nem at vedligeholde og understøtte over tid. Det er nemmere at tackle fejl og sikre sikkerhed i velorganiseret kode, der følger Rust-fællesskabets regler og konventioner.

Som standard sikrer Rust, at programmer er hukommelsessikre med en indbygget ejerskabsmodel. Ejerskabsmodellen sikrer hukommelsessikkerhed ved at sikre, at variabler i hukommelsen har én unik ejer. Ejerskabsmodellen forhindrer dataspor og mange typer hukommelsesfejl.