Rūdžių projektų su paketais, takais ir moduliais organizavimas

Rūdys yra puikus pasirinkimas sudėtingoms ir patikimoms statyboms. Vienas iš esminių įgūdžių kuriant Rust programas yra efektyvus projektų struktūrizavimas, įskaitant trečiųjų šalių paketų įtraukimą.

Veiksmingas projekto organizavimas yra labai svarbus kuriant Rust programas. Geros struktūros „Rust“ programos pagerina bendradarbiavimą ir lengvą trečiųjų šalių programų integravimą, žymiai sumažindamos laiką ir pastangas, kurių reikia programai kurti. Rust suteikia integruotą paketų tvarkyklę ir kitus įrankius efektyviam kodo organizavimui ir valdymui.

Rūdžių projektų nustatymas

„Rust“ projektus nustatyti lengva Įdiegę Rust savo kompiuteryje; galite naudoti Cargo (Rust integruotą paketų tvarkyklę ir kūrimo sistemą), kad sukurtumėte ir sukonfigūruotumėte Rust projektą. Tai panašu į kitus paketų tvarkykles npm Node.js ir pip, skirtas Python. „Cargo“ valdo priklausomybes, kompiliuoja kodą ir generuoja dokumentaciją, todėl tai yra esminis „Rust“ kūrimo įrankis.

Paleiskite šią komandą, kad patikrintumėte savo krovinio diegimą:

krovinys -- versija

Komanda rodo įdiegtą „Cargo“ versiją.

Galite sukurti naują Rust projektą naudodami krovinys naujas komandą. Turėsite nurodyti projekto pavadinimą.

krovinys naujas mano_projektas

Komanda sukurs naują katalogą dabartiniame kataloge, kuriame yra pagrindiniai failai, kurių jums reikia „Rust“ projektui, įskaitant a krovinys.toml failą, skirtą jūsų projekto priklausomybėms valdyti.

Rūdžių paketo vardų erdvė

Paketai ir dėžės yra esminiai Rust komponentai. Dėžės yra bibliotekos arba dvejetainiai failai, kuriuos Rust kūrėjai gali naudoti ir sudaryti tam tikram tikslui, o paketai yra dėžių rinkinys. Paketuose paprastai yra dėžė, kurioje yra daugkartinio naudojimo kodas, ir dvejetainis failas, suteikiantis bibliotekos dėžės CLI.

Dėžėse turi būti Krovinys.toml failą, kuriame yra metaduomenys apie paketą, pvz., jo pavadinimas, versija, priklausomybės ir kūrimo scenarijai.

Rūdžių paketai vadovaujasi pavadinimų suteikimo sutartimi, kad būtų išvengta pavadinimų konfliktų tarp paketų. Paketų pavadinimai turi būti visame pasaulyje unikalūs, mažosiomis raidėmis ir juose turi būti tik raidės, skaitmenys ir brūkšneliai. Jei paketo pavadinime yra keli žodžiai, atskirkite juos brūkšneliais, pvz. hiper-serveris.

Kodą galite pasiekti „Rust“ paketo vardų srityje naudodami naudoti raktinis žodis, po kurio nurodomi paketo ir dėžės pavadinimai.

Štai pavyzdys, kaip importuoti Rng funkcija iš a rand dėžė:

naudoti rand:: Rng;

Galite sukurti kelias paketų vardų sritis. Kai kuriate aplanką, sukuriate naują vardų erdvę, kurią galite pasiekti naudodami taško žymėjimą, kad nurodytumėte kelią iki identifikatoriaus.

„Rust“ paketams gali būti kelios vardų erdvės. Kai kuriate aplanką, sukuriate naują vardų erdvę. Norėdami pasiekti kodą iš kitos vardų erdvės, naudokite tašką, kad nurodytumėte kelią į identifikatorių.

Štai pavyzdys, kaip pasiekti funkciją iš kitos vardų srities:

// failas aplanko 1 vardų erdvėje
pubfnaplanką() -> u32 {
// čia kažkoks funkcinis kūnas
grąžinti0;
}
// failas aplanko2 vardų erdvėje
naudoti aplankas1::aplankas;
pubfnkatalogas() {
// prieiga prie aplanko funkcijos iš aplanko1 vardų erdvės
leisti folder_func = aplankas();
}

Programa apibrėžia du „Rust“ modulius skirtingose ​​vardų srityse, aplankas1 ir aplankas2 atitinkamai. The aplankas1 modulyje yra viešoji funkcija aplanką kuri grąžina 32 bitų beženklio sveikojo skaičiaus reikšmę.

The aplankas2 modulis importuoja aplanką funkcija iš aplankas1 vardų sritis su naudoti raktinis žodis, leidžiantis katalogas funkcija pasiekti aplanką funkcija iš aplankas1 modulis. The katalogas funkcija iškviečia aplanką funkcija, o grąžinamoji vertė priskiriama folder_func kintamasis.

Norėdami eksportuoti, paketo ar dėžutės identifikatorių pavadinimus turėsite rašyti didžiosiomis raidėmis. Kai eksportuojate identifikatorių, padarote jį pasiekiamą kituose paketuose, kuriuose naudojamas kodas.

Štai viešosios funkcijos, kurią galima eksportuoti, pavyzdys.

// funkcija eksportuota į kitus paketus ir dėžes
pubfnMano funkcija() {
// čia kažkoks funkcinis kūnas
}

Taip pat turėsite naudoti pub raktažodį. Rūdyje, pub raktinis žodis yra trumpinys viešas. Kai funkcija, struktūra, enum, bet koks Rust duomenų tipas arba modulis pažymėtas pub raktažodžiu, jis tampa pasiekiamas už jo modulio ribų. Elementas yra privatus jo moduliui be pub raktinio žodžio ir gali būti pasiekiamas tik iš jo.

Modulių apibrėžimas valdymui ir privatumui

Galite naudoti modulius, kad galėtumėte valdyti Rust programų apimtį ir privatumą. Moduliai leidžia suskirstyti kodą į loginius vienetus, kuriuos lengviau valdyti ir prižiūrėti.

Modulius galite deklaruoti naudodami mod raktinis žodis, po kurio nurodomas modulio pavadinimas ir riestiniai skliaustai. Apibrėžus naują modulį, jo turiniui sukuriama nauja vardų erdvė, o tai reiškia, kad funkcijos, struktūros arba kiti modulyje apibrėžti elementai pasiekiami tik modulyje, nebent jūs aiškiai eksportuojate juos.

Moduliai padeda išvengti pavadinimų konfliktų, todėl kodą lengviau suprasti.

Štai paprasto modulio sintaksė:

mod mano_modulis {
// modulio turinys eina čia
}

Modulio viduje galite apibrėžti kintamuosius, funkcijas, struktūras, sąrašus ir kitus tipus.

mod mano_modulis {
fnpridėti_skaičiai(a: i32, b: i32) -> i32 {
 a + b
 }
}

Galite naudoti pub raktažodį funkcijai eksportuoti ir funkcijai pasiekti kitose programos dalyse.

mod mano_modulis {
pubfnpridėti_skaičiai(a: i32, b: i32) -> i32 {
 a + b
 }
}

Dabar galite paskambinti pridėti_skaičiai funkcija iš kitų jūsų programos dalių.

Taip pat galite valdyti modulių privatumą naudodami pub raktinis žodis apie modulių apibrėžimus.

pubmod mano_modulis {
pubfnpridėti_skaičiai(a: i32, b: i32) -> i32 {
 a + b
 }
}

Dabar, mano_modulis modulis yra viešas, o modulį galite pasiekti iš kitų modulių.

Jei reikia, kad modulis ar elementas būtų pasiekiamas konkrečiam moduliui ar modulių rinkiniui, galite naudoti baras (dėžė) raktažodį. The baras (dėžė) raktinis žodis leidžia pasiekti elementą iš modulių, esančių toje pačioje dėžėje, bet ne iš modulių kitose dėžėse.

mod mano_modulis {
pubstruktūra„MyStruct“. {
pub(dėžė) some_field: u32,
 }
}

Dabar galite pasiekti konkretų elementą (šiuo atveju kai_laukas srityje „MyStruct“. struct) kitose programos dalyse.

fnpagrindinis() {
leisti mano_struktūra = mano_modulis:: MyStruct { some_field: 42 };
println!("{}", my_struct.some_field);
}

The mano_struktūra kintamasis yra pavyzdys „MyStruct“. struktūra. Kintamasis pasiekia struktūrą su kelio skyrikliu (::). The pagrindinis funkcija spausdina kai_laukas konstrukcijos laukas su println! makrokomandą.

Rust nuosavybės modelis užtikrina atminties saugumą

Rūdžių kodo tvarkymas yra vienas iš būdų užtikrinti, kad kodą būtų lengva prižiūrėti ir palaikyti laikui bėgant. Lengviau pašalinti klaidas ir užtikrinti saugumą naudojant gerai organizuotą kodą, kuris atitinka Rust bendruomenės taisykles ir konvencijas.

Pagal numatytuosius nustatymus „Rust“ užtikrina, kad programos būtų saugios atmintyje su integruotu nuosavybės modeliu. Nuosavybės modelis užtikrina atminties saugumą, nes atmintyje esantys kintamieji turi vieną unikalų savininką. Nuosavybės modelis apsaugo nuo duomenų pėdsakų ir daugelio tipų atminties klaidų.