Rozsdaprojektek szervezése csomagokkal, útvonalakkal és modulokkal

A rozsda kiváló választás összetett és megbízható alkalmazások építéséhez. A Rust alkalmazások fejlesztésének egyik alapvető készsége a projektek hatékony strukturálása, beleértve a harmadik féltől származó csomagok beépítését.

A hatékony projektszervezés kulcsfontosságú a Rust alkalmazások fejlesztéséhez. A jól strukturált Rust alkalmazások javítják az együttműködést és a harmadik féltől származó alkalmazások egyszerű integrációját, jelentősen csökkentve az alkalmazásfejlesztéshez szükséges időt és erőfeszítést. A Rust beépített csomagkezelőt és egyéb eszközöket biztosít a hatékony kódszervezéshez és -kezeléshez.

Rozsdaprojektek beállítása

A Rust projektek beállítása egyszerű miután telepítette a Rust-ot a gépére; használhatja a Cargo-t (a Rust beépített csomagkezelője és összeállítási rendszere) Rust projekt létrehozásához és konfigurálásához. Hasonló a többi csomagkezelőhöz, mint pl

npm a Node.js számára és pip a Python számára. A Cargo kezeli a függőségeket, kódot fordít és dokumentációt generál, így a Rust fejlesztés elengedhetetlen eszköze.

Futtassa ezt a parancsot a rakomány telepítésének ellenőrzéséhez:

rakomány -- változat

A parancs megjeleníti a telepített Cargo verziót.

Új Rust projektet hozhat létre a rakomány új parancs. Meg kell adnia a projekt nevét.

cargo new my_project

A parancs létrehoz egy új könyvtárat az aktuális könyvtárban, amely tartalmazza a Rust projekthez szükséges alapvető fájlokat, beleértve a rakomány.toml fájl a projekt függőségeinek kezelésére.

A rozsdacsomag névtér

A csomagok és ládák a Rust alapvető alkotóelemei. A ládák olyan könyvtárak vagy binárisok, amelyeket a Rust fejlesztői használhatnak és lefordíthatnak bizonyos célra, a csomagok pedig ládák gyűjteményét jelentik. A csomagok általában tartalmaznak egy ládát, amely az újrafelhasználható kódot tartalmazza, és egy bináris fájlt, amely CLI-t biztosít a könyvtári láda számára.

A ládáknak tartalmazniuk kell a Cargo.toml fájl, amely metaadatokat tartalmaz a csomagról, például a nevét, verzióját, függőségeit és felépítési szkriptjeit.

A rozsdás csomagok elnevezési konvenciót követnek, hogy elkerüljék a csomagok közötti elnevezési ütközéseket. A csomagneveknek globálisan egyedinek, kisbetűsnek kell lenniük, és csak betűket, számokat és kötőjeleket kell tartalmazniuk. Ha egy csomagnév több szót tartalmaz, válassza el őket kötőjellel, pl. hiper-szerver.

A Rust csomag névterén belüli kódot a következővel érheti el használat kulcsszó, majd a csomag és a láda neve.

Íme egy példa egy Rng függvény a rand láda:

használat rand:: Rng;

Több névteret is létrehozhat a csomagokhoz. Mappa létrehozásakor új névteret hoz létre, amelyet a pont jelöléssel érhet el, és megadhatja az azonosító elérési útját.

A Rustban több névtér is lehet a csomagokhoz. Mappa létrehozásakor új névteret hoz létre. Ha egy másik névtérből szeretne kódot elérni, akkor egy pont jelöléssel adja meg az azonosító elérési útját.

Íme egy példa egy függvény más névtérből való elérésére:

// fájl a mappa1 névtérben
kocsmafnmappát() -> u32 {
// itt valami funkciótest
Visszatérés0;
}
// fájl a mappa2 névtérben
használat mappa1::mappa;
kocsmafnKönyvtár() {
// a mappa funkció elérése a mappa1 névtérből
hagyja mappa_func = mappa();
}

A program két Rust modult határoz meg különböző névterekben, mappa1 és mappa2 illetőleg. A mappa1 modul nyilvános funkciót tartalmaz mappát amely 32 bites előjel nélküli egész értéket ad vissza.

A mappa2 modul importálja a mappát funkció a mappa1 névtér a használat kulcsszó, amely lehetővé teszi a Könyvtár funkció eléréséhez mappát funkció a mappa1 modult. A Könyvtár függvény meghívja a mappát függvényt, és a visszatérési érték hozzá van rendelve a mappa_func változó.

Az exportáláshoz nagybetűvel kell írnia a csomagban vagy rekeszben lévő azonosítók nevét. Amikor exportál egy azonosítót, akkor azt elérhetővé teszi más, a kódot használó csomagokban.

Íme egy példa egy exportálható nyilvános függvényre.

// függvény exportálva más csomagokba és ládákba
kocsmafnMyFunction() {
// itt valami funkciótest
}

Használnia kell továbbá a kocsma kulcsszó. Rustban a kocsma a kulcsszó rövidítése nyilvános. Amikor egy függvény, struktúra, enum, bármilyen Rust adattípus vagy modul a pub kulcsszóval van megjelölve, akkor a modulján kívül válik elérhetővé. Az elem privát a moduljában, a pub kulcsszó nélkül, és csak abból érhető el.

Modulok meghatározása a hatókör és az adatvédelem szabályozásához

Modulokat használhat a Rust programok hatókörének és adatvédelmének szabályozására. A modulok lehetővé teszik a kód logikai egységekbe rendezését, amelyek könnyebben kezelhetők és karbantarthatók.

A modulokat a mod kulcsszó után a modul neve és a kapcsos zárójelek. Egy új modul meghatározása új névteret hoz létre a tartalmának, ami azt jelenti, hogy függvények, struktúrák, ill. a modulban meghatározott többi elem csak a modulon belül érhető el, kivéve, ha kifejezetten exportál őket.

A modulok segítenek megelőzni az elnevezési ütközéseket, így a kód érthetőbbé válik.

Íme egy egyszerű modul szintaxisa:

mod my_module {
// a modul tartalma ide kerül
}

A modulon belül definiálhatunk változókat, függvényeket, struktúrákat, enumokat és egyéb típusokat.

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

Használhatja a kocsma kulcsszó a függvény exportálásához és a függvény más részeiben való eléréséhez.

mod my_module {
kocsmafnadd_numbers(a: i32, b: i32) -> i32 {
 a + b
 }
}

Most már felhívhatja a add_numbers funkciót a program más részeiből.

A modulok titkosságát is szabályozhatja a kocsma kulcsszó a moduldefinícióknál.

kocsmamod my_module {
kocsmafnadd_numbers(a: i32, b: i32) -> i32 {
 a + b
 }
}

Most a my_module modul nyilvános, és a modult más modulokból is elérheti.

Ha egy modult vagy elemet egy adott modul vagy modulkészlet számára elérhetővé kell tenni, használhatja a kocsma (láda) kulcsszó. A kocsma (láda) A kulcsszó elérhetővé teszi az elemet az ugyanabban a ládában lévő modulokból, de nem a más ládákban lévő modulokból.

mod my_module {
kocsmastructMyStruct {
kocsma(láda) some_field: u32,
 }
}

Most már hozzáférhet az adott elemhez (ebben az esetben a some_field területén a MyStruct struct) a program más részein.

fnfő-() {
hagyja my_struct = my_module:: MyStruct { some_field: 42 };
println!("{}", my_struct.some_field);
}

A my_struct változó a MyStruct struct. A változó eléri a struktúrát az útvonalelválasztóval (::). A fő- függvény kiírja a some_field a struktúra mezője a println! makró.

A Rust tulajdonosi modellje garantálja a memória biztonságát

A Rust kód rendszerezése az egyik módja annak, hogy a kód könnyen karbantartható és idővel támogassa. Könnyebb kezelni a hibákat és biztosítani a biztonságot egy jól szervezett kóddal, amely követi a Rust közösségi szabályait és konvencióit.

Alapértelmezés szerint a Rust beépített tulajdonosi modellel biztosítja a programok memóriabiztonságát. A tulajdonosi modell biztosítja a memória biztonságát azáltal, hogy a memóriában lévő változóknak egyetlen tulajdonosa van. A tulajdonosi modell megakadályozza az adatok nyomait és sokféle memóriahibát.