Organisering av rustprosjekter med pakker, stier og moduler

Rust er et utmerket valg for å bygge komplekse og pålitelige applikasjoner. En av de essensielle ferdighetene for å utvikle Rust-applikasjoner er å strukturere prosjektene dine effektivt, inkludert å inkludere tredjepartspakker.

Effektiv prosjektorganisering er avgjørende for å utvikle Rust-applikasjoner. Godt strukturerte Rust-apper forbedrer samarbeid og enkle tredjeparts app-integrasjoner, noe som reduserer tiden og innsatsen som kreves for apputvikling betraktelig. Rust gir en innebygd pakkebehandling og andre verktøy for effektiv kodeorganisering og -administrasjon.

Sette opp rustprosjekter

Det er enkelt å sette opp Rust-prosjekter når du har installert Rust på maskinen din; du kan bruke Cargo (Rusts innebygde pakkebehandling og byggesystem) for å opprette og konfigurere et Rust-prosjekt. Det ligner på andre pakkeforvaltere npm for Node.js og pip for Python. Cargo administrerer avhengigheter, kompilerer kode og genererer dokumentasjon, noe som gjør det til et viktig verktøy for Rust-utvikling.

Kjør denne kommandoen for å bekrefte Cargo-installasjonen:

last --versjon

Kommandoen viser den installerte Cargo-versjonen.

Du kan opprette et nytt Rust-prosjekt med last ny kommando. Du må spesifisere prosjektnavnet.

last nytt mitt_prosjekt

Kommandoen vil opprette en ny katalog i gjeldende katalog som inneholder de grunnleggende filene du trenger for Rust-prosjektet, inkludert en cargo.toml fil for å administrere prosjektets avhengigheter.

Rustpakkens navneområde

Pakker og kasser er essensielle komponenter i Rust. Kasser er biblioteker eller binærfiler som Rust-utviklerne kan bruke og kompilere for en bestemt bruk, og pakker er en samling kasser. Pakker inneholder vanligvis en kasse som inneholder den gjenbrukbare koden og en binær som gir en CLI for bibliotekkassen.

Kasser må inneholde Cargo.toml fil som inneholder metadata om pakken, for eksempel dens navn, versjon, avhengigheter og byggeskript.

Rustpakker følger en navnekonvensjon for å unngå navnekonflikter mellom pakker. Pakkenavn må være globalt unike, små bokstaver og kun inneholde bokstaver, sifre og bindestreker. Hvis et pakkenavn inneholder flere ord, skiller du dem med bindestreker, f.eks. hyper-server.

Du kan få tilgang til kode i et Rust-pakkenavnområde med bruk nøkkelord etterfulgt av pakken og kassenavnene.

Her er et eksempel på import av en Rng funksjon fra a rand kasse:

bruk rand:: Rng;

Du kan opprette flere navneområder for pakker. Når du oppretter en mappe, oppretter du et nytt navneområde som du kan få tilgang til med punktnotasjonen for å spesifisere banen til identifikatoren.

I Rust kan det være flere navneområder for pakker. Når du oppretter en mappe, oppretter du et nytt navneområde. For å få tilgang til kode fra et annet navneområde bruker du en punktnotasjon for å spesifisere banen til identifikatoren.

Her er et eksempel på tilgang til en funksjon fra et annet navneområde:

// fil i mappe1 navneområde
pubfnmappe() -> u32 {
// noen funksjonstekst her
komme tilbake0;
}
// fil i mappe2 navneområde
bruk mappe1::mappe;
pubfnkatalog() {
// tilgang til mappefunksjonen fra mappe1-navneområdet
la folder_func = mappe();
}

Programmet definerer to Rust-moduler i forskjellige navnerom, mappe1 og mappe2 hhv. De mappe1 modul inneholder en offentlig funksjon mappe som returnerer en 32-bits usignert heltallsverdi.

De mappe2 modul importerer mappe funksjon fra mappe1 navneområde med bruk nøkkelord, slik at katalog funksjon for å få tilgang til mappe funksjon fra mappe1 modul. De katalog funksjonen kaller mappe funksjon, og returverdien tilordnes til folder_func variabel.

Du må skrive navnet på identifikatorene fra en pakke eller kasse med stort forbokstav for å eksportere dem. Når du eksporterer en identifikator, gjør du den tilgjengelig i andre pakker som bruker koden.

Her er et eksempel på en offentlig funksjon som kan eksporteres.

// funksjon eksportert til andre pakker og kasser
pubfnMyFunction() {
// noen funksjonstekst her
}

Du må også bruke pub nøkkelord. I Rust, den pub nøkkelord er forkortelse for offentlig. Når en funksjon, struktur, enum, alle typer rustdata eller modulen er merket med pub-nøkkelordet, blir den tilgjengelig utenfor modulen. Elementet er privat for sin modul uten pub-nøkkelordet og kan bare nås fra det.

Definere moduler for å kontrollere omfang og personvern

Du kan bruke moduler til å kontrollere omfang og personvern i Rust-programmer. Moduler lar deg organisere kode i logiske enheter som er enklere å administrere og vedlikeholde.

Du kan deklarere moduler med mod nøkkelord etterfulgt av modulnavnet og bukseseler. Å definere en ny modul oppretter et nytt navneområde for innholdet, noe som betyr at funksjoner, strukturer eller andre elementer definert i modulen er bare tilgjengelige i modulen, bortsett fra at du eksplisitt eksporterer dem.

Moduler bidrar til å forhindre navnekonflikter, noe som gjør koden mer intuitiv å forstå.

Her er syntaksen for en enkel modul:

mod min_modul {
// modulinnhold gå her
}

Innenfor modulen kan du definere variabler, funksjoner, strukturer, enums og andre typer.

mod min_modul {
fnadd_numbers(en: i32, b: i32) -> i32 {
 a + b
 }
}

Du kan bruke pub nøkkelord for å eksportere funksjonen og få tilgang til funksjonen i andre deler av programmet.

mod min_modul {
pubfnadd_numbers(en: i32, b: i32) -> i32 {
 a + b
 }
}

Nå kan du ringe add_numbers funksjon fra andre deler av programmet.

Du kan også kontrollere personvernet til moduler med pub nøkkelord på moduldefinisjoner.

pubmod min_modul {
pubfnadd_numbers(en: i32, b: i32) -> i32 {
 a + b
 }
}

Nå, den min_modul modulen er offentlig, og du kan få tilgang til modulen fra andre moduler.

Hvis du trenger å gjøre en modul eller et element tilgjengelig for en bestemt modul eller et sett med moduler, kan du bruke pub (kasse) nøkkelord. De pub (kasse) nøkkelord gjør elementet tilgjengelig fra moduler i samme kasse, men ikke fra moduler i andre kasser.

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

Du kan nå få tilgang til det spesifikke elementet (i dette tilfellet noen_felt felt av MyStruct struct) i andre deler av programmet.

fnhoved-() {
la my_struct = my_module:: MyStruct { some_field: 42 };
println!("{}", my_struct.some_field);
}

De min_struktur variabel er en forekomst av MyStruct struktur. Variabelen får tilgang til strukturen med baneseparatoren (::). De hoved- funksjonen skriver ut noen_felt felt av strukturen med println! makro.

Rusts eierskapsmodell sikrer minnesikkerhet

Organisering av rustkode er en måte å sikre at koden din er enkel å vedlikeholde og støtte over tid. Det er lettere å takle feil og sikre sikkerhet i velorganisert kode som følger Rust-fellesskapets regler og konvensjoner.

Som standard sørger Rust for at programmene er minnesikre med en innebygd eierskapsmodell. Eierskapsmodellen sikrer minnesikkerhet ved å sikre at variabler i minnet har én unik eier. Eierskapsmodellen forhindrer dataspor og mange typer minnefeil.