Rust tulajdonságainak és élettartamának megértése

A tulajdonságok és az élettartam a Rust kulcsfontosságú összetevői. Jellemzők segítségével meghatározhatja az implementálandó típusok viselkedését és képességeit. Nagyon sokoldalúak, lehetővé téve általánosabb kód írását, csökkentve a duplikációt és javítva a karbantarthatóságot.

A Rust egy másik mechanizmust – élettartamokat – használ a hatókörön belüli és azon kívüli változók tulajdonjogának nyomon követésére. Ez megakadályozza, hogy a mutatók lelógjanak a változó felosztása során.

A tulajdonságok és az élettartamok együttesen biztosítják a típusbiztonságot, a memóriabiztonságot és a kód megbízhatóságát.

A Rozsda tulajdonságainak megértése

A tulajdonságok olyan módszerek gyűjteményei, amelyeket más típusok is megvalósíthatnak. A tulajdonságok hasonlóak a interfészek olyan nyelveken, mint a Java, Go és TypeScript, de rugalmasabb.

Használja a jellemvonás kulcsszó a Rust jellemzőinek meghatározásához, majd a metódus aláírások deklarációja.

jellemvonásMyTrait {
fnaz én_módszerem(&maga);
}

A kód egy elnevezett tulajdonságot határoz meg MyTrait val,-vel az én_módszerem módszer. A &maga paraméter azt jelzi, hogy a metódus első paramétereként az implementációs típus objektumára hivatkozik.

Egy tulajdonság definiálása után implementálhatja az egyéni típusaihoz.

Itt van, hogyan valósíthat meg egy tulajdonságot a struktúratípusaihoz.

structSzemély {
 név: Húr,
 kor: u32,
}
impl Info számára személy {
fnösszefoglaló(&maga) {
println!("A nevem {}, és {} éves vagyok.", maga.név, maga.kor);
 }
}

A Személy struct eszközöket Info, és felhívhatja a összefoglaló módszer a példányain Személy struct.

fnfő-(){
hagyja john = személy { név: Húr::tól től("János"), életkor: 30 };
 john.summary(); // Kimenet: A nevem John, és 30 éves vagyok.
}

A János változó a Személy struct.

A fő- függvényhívások összefoglaló amely egy üzenetet nyomtat a konzolra:

Az enumok tulajdonságokat valósíthatnak meg. Így definiálhat egy enumot olyan változatokkal, amelyek megvalósítják a összefoglaló módszer:

enumMyEnum {
 A változat,
 B változat,
}
impl Info számára MyEnum {
fnösszefoglaló(&maga) {
mérkőzésmaga {
 MyEnum:: VariantA => {
// A VariantA megvalósítása
 }
 MyEnum:: VariantB => {
// megvalósítás a VariantB számára
 }
 }
 }
}

Jellemzők használata függvényparaméterekhez és visszatérési értékekhez

A tulajdonságokat függvényparaméterként és visszatérési értékként használhatja. A tulajdonságok funkcióparaméterként való használata praktikus több típusú általános kód írásához.

Itt van egy függvény, amely bármilyen típusú paramétert felvesz, amely megvalósítható Info.

fncsinálj valamit(érték: T) {
 érték.összegzés();
}

A szintaxisa ezt határozza meg T végre kell hajtani Info. Felhívhatja a összefoglaló függvény bármilyen értékkel, amely megvalósítja Info.

Élettartamok Rustban

A Rust kölcsönellenőrző eszköze elemzi a programokat, és biztosítja a megfelelő memóriahasználatot. Rozsdában, minden értéknek van tulajdonosa ez felelős az érték felosztásáért. Amikor a változók értékeket kölcsönöznekkölcsönöznek egy utalást az átadott értékre, de a tulajdonos megtartja a tulajdonjogot.

Az élettartamok biztosítják a kölcsönzött értékek helyes felhasználását. Az élettartam egy hivatkozáshoz csatolt címke, amely leírja, mennyi ideig érvényes a hivatkozás.

A Rustban egy élettartamot adhat meg egy aposztróf megjegyzéssel:

func<'a>

Referencia létrehozásakor a hivatkozáshoz hozzárendel egy élettartamot, amely leírja, hogy meddig érvényes. Ha olyan függvénye van, amely hivatkozik egy értékre, az élettartamnak hosszabbnak kell lennie, mint a függvényhívásé, hogy az érték érvényes legyen, amikor a függvény visszatér.

Íme egy példa egy függvény élettartam-specifikációjára.

fncsinálj valamit<'a>(x: &'ai32) -> &'ai32 {
 x
}
fnfő-() {
hagyja x = 42;
hagyja eredmény = do_something(&x);
println!("Az eredmény: {}", eredmény);
}

Ban,-ben csinálj valamit funkció, a 'a élettartam paraméter azt jelzi, hogy a hivatkozás x a függvényhívás erejéig érvényes. A visszaadott hivatkozás a függvényhívás erejéig érvényes.

A fő- függvény kiírja az eredményt a hivatkozás átadásával x változó a fő- funkciót a konzolhoz.

Az élettartam szintaxisa lehet bőbeszédű, de elengedhetetlen a biztonság és a memóriakezelés szempontjából. A három élettartamra szóló Elision szabályok olyan iránymutatásokat adnak, amelyek lehetővé teszik a Rust számára, hogy bizonyos helyzetekben következtessen a hivatkozások élettartamára.

A bemeneti élettartam szabálya

A bemeneti élettartamra vonatkozó szabály azt határozza meg, hogy ha egy függvény vagy metódus egy vagy több hivatkozást vesz fel bemeneti paraméterként, a Rust azt feltételezi, hogy az összes referencia élettartama azonos.

Egyszerűen fogalmazva, a kimeneti hivatkozások élettartama ugyanaz lesz, mint a bemeneti referenciáké.

fnleghosszabb<'a>(x: &'astr, y: &'astr) -> &'astr {
ha x.len() > y.len() { x } más { y }
}

Ban,-ben leghosszabb függvény, a Rust arra következtet, hogy a kimeneti referencia élettartama megegyezik a bemeneti referencia élettartamával, mivel mindkettőnek ugyanaz az élettartam paramétere 'a.

A bemeneti élettartam szabálya megkönnyíti az általános függvények írását, amelyek több hivatkozást is használnak bevitelként.

A kimeneti élettartam szabálya

A kimeneti élettartamra vonatkozó szabály azt határozza meg, hogy ha egy függvény vagy metódus referenciát ad vissza, a Rust azt feltételezi, hogy a kimeneti referencia élettartama eltér bármely bemeneti referencia élettartamától.

fnelső szó<'a>(s: &'astr) -> &'astr {
 s.split_whitespace().next().unwrap()
}

Ebben a függvényben Rust arra következtet, hogy a kimeneti referencia élettartama eltér a bemeneti referencia élettartamától, mivel split_whitespace() metódus olyan kimeneti referenciát hoz létre, amely nem vesz fel bemeneti referenciaparamétereket.

Az élethosszig tartó szabály

Az élettartamra vonatkozó szabály akkor érvényes, ha egy függvény vagy metódus egy hivatkozást vagy bemeneti paramétert vesz fel, és egy referenciát ad vissza. Ebben az esetben a Rust azt feltételezi, hogy a kimeneti referencia élettartama megegyezik a bemeneti referencia élettartamával.

fnleghosszabb<'a>(x: &'astr, y: &str) -> &'astr {
ha x.len() > y.len() { x } más { y }
}

Ebben a függvényben a Rust arra következtet, hogy a kimeneti referencia élettartama megegyezik a bemeneti referencia élettartamával, mivel a bemeneti referencia y nincs élettartam paramétere. A rozsda kihagyja az élettartam paramétert y és feltételezi, hogy élettartama megegyezik x.

Ez a szabály megkönnyíti olyan függvények írását, amelyek egy bemeneti referenciát vesznek fel, és egy kimeneti hivatkozást adnak vissza.

Jellemzők és élettartamok

A tulajdonságok és az élettartamok kombinálásával olyan általános függvényeket hozhat létre, amelyek olyan típusokhoz működnek, amelyek egy tulajdonságot valósítanak meg, és érvényes élettartammal rendelkeznek.

Itt van egy tulajdonság és egy függvény, amely a tulajdonságot megvalósító értékre hivatkozik.

jellemvonásToString {
fnto_string(&maga) -> Húr;
}
fnto_string<'a, T: ToString>(t: &'a T) -> Húr {
 t.to_string()
}

Itt az élettartam paraméter 'a biztosítja, hogy a hivatkozás t érvényes a hivatkozott objektum élettartama alatt. Használhatja a to_string funkciót megvalósító típusokkal ToString érvényes élettartammal rendelkező tulajdonság.

A tulajdonságok képezik az alapját az OOP-koncepciók Rust-ban való megvalósításának

A tulajdonságok lehetővé teszik a viselkedések meghatározását. Bár a Rust nem egy objektum-orientált programozási nyelv (OOP), felhasználhatja a tulajdonságokat az OOP-koncepciók megvalósítására a beágyazástól az öröklődésig, a polimorfizmusig és az absztrakcióig.

Ezen OOP-koncepciók jellemzőkkel való implementálása a Rust-programokat méretezhetővé, robusztussá, karbantarthatóvá és hatékonysá teszi.