Pochopenie Rustových vlastností a životov

Vlastnosti a životnosť sú kľúčovými zložkami hrdze. Vlastnosti môžete použiť na definovanie správania a schopností typov na implementáciu. Sú veľmi všestranné a umožňujú vám písať generickejší kód, znížiť duplicitu a zlepšiť udržiavateľnosť.

Rust používa ďalší mechanizmus – životnosť – na sledovanie vlastníctva premenných v rozsahu a mimo neho. Toto zabraňuje visiacim ukazovateľom počas variabilného rozdelenia.

Vlastnosti a životnosť spoločne pomáhajú zaistiť bezpečnosť typu, bezpečnosť pamäte a spoľahlivosť kódu.

Pochopenie vlastností v Rust

Vlastnosti sú kolekcie metód, ktoré môžu implementovať iné typy. Vlastnosti sú podobné ako rozhrania v jazykoch ako Java, Go a TypeScript, ale flexibilnejšie.

Budete používať vlastnosť kľúčové slovo na definovanie vlastností v Ruste, po ktorom nasleduje deklarácia podpisov metód.

vlastnosťMyTrait {
fnmoja_metóda(&seba);
}

Kód definuje vlastnosť pomenovanú

MyTrait s moja_metóda metóda. The &ja parameter označuje, že metóda odkazuje na objekt implementačného typu ako svoj prvý parameter.

Po definovaní vlastnosti ju môžete implementovať pre svoje vlastné typy.

Tu je návod, ako môžete implementovať vlastnosť pre svoje typy štruktúr.

štrukturovaťOsoba {
 názov: Reťazec,
 Vek: u32,
}
impl Info pre Osoba {
fnzhrnutie(&seba) {
println!("Volám sa {} a mám {} rokov.", seba.názov, seba.Vek);
 }
}

The Osoba konštrukčné náradie Infoa môžete zavolať na zhrnutie metóda na príkladoch Osoba štrukturovať.

fnHlavná(){
nech john = Osoba { meno: Reťazec::od("John"), Vek: 30 };
 john.summary(); // Výstup: Volám sa John a mám 30 rokov.
}

The John premenná je inštanciou premennej Osoba štrukturovať.

The Hlavná volania funkcií zhrnutie ktorý vypíše správu do konzoly:

Enumy môžu implementovať vlastnosti. Tu je návod, ako môžete definovať zoznam s variantmi, ktoré implementujú zhrnutie metóda:

enumMyEnum {
 Variant A,
 Variant B,
}
impl Info pre MyEnum {
fnzhrnutie(&seba) {
zápasseba {
 MyEnum:: VariantA => {
// implementácia pre VariantA
 }
 MyEnum:: VariantB => {
// implementácia pre VariantB
 }
 }
 }
}

Použitie vlastností pre funkčné parametre a návratové hodnoty

Vlastnosti môžete použiť ako parametre funkcie a návratové hodnoty. Používanie vlastností ako parametrov funkcie je užitočné pri písaní všeobecného kódu s viacerými typmi.

Tu je funkcia, ktorá preberá parameter akéhokoľvek typu, ktorý implementuje Info.

fnurob niečo(hodnota: T) {
 hodnota.summary();
}

The syntax to špecifikuje T musí implementovať Info. Môžete zavolať na zhrnutie funkciu s akoukoľvek hodnotou, ktorá sa implementuje Info.

Životy v Ruste

Nástroj na kontrolu výpožičiek od spoločnosti Rust analyzuje programy a zabezpečuje správne využitie pamäte. V Ruste, každá hodnota má svojho majiteľa ktorý je zodpovedný za prerozdelenie hodnoty. Kedy premenné si požičiavajú hodnoty, požičia si odkaz na odovzdanú hodnotu, ale vlastník si ponecháva vlastníctvo.

Životnosť je spôsob, ako zabezpečiť, aby sa vypožičané hodnoty používali správne. Životnosť je štítok pripojený k referencii, ktorý popisuje, ako dlho je referencia platná.

V Rust môžete určiť životnosť pomocou apostrofovej anotácie:

func<'a>

Pri vytváraní referencie je referencii priradená životnosť, ktorá popisuje, ako dlho je platná. Ak máte funkciu, ktorá má odkaz na hodnotu, životnosť musí byť dlhšia ako volanie funkcie, aby sa zabezpečilo, že hodnota je platná, keď sa funkcia vráti.

Tu je príklad špecifikácie životnosti vo funkcii.

fnurob niečo<'a>(x: &'ai32) -> &'ai32 {
 X
}
fnHlavná() {
nech x = 42;
nech vysledok = nieco urobit(&x);
println!("Výsledok je: {}", výsledok);
}

V urob niečo funkcia, 'a parameter životnosti označuje, že odkaz na X je platný, kým je volanie funkcie. Vrátená referencia je platná aj počas volania funkcie.

The Hlavná funkcia vypíše výsledok odovzdaním odkazu na X premenná v Hlavná funkciu do konzoly.

Syntax životnosti môže byť podrobná, ale je nevyhnutná pre bezpečnosť a správu pamäte. Pravidlá trojnásobnej životnosti poskytujú pokyny, ktoré umožňujú Rustovi odvodiť životnosť referencií v určitých situáciách.

Pravidlo životnosti vstupu

Pravidlo životnosti vstupu určuje, že ak funkcia alebo metóda berie ako vstupné parametre jeden alebo viac odkazov, Rust predpokladá, že všetky odkazy majú rovnakú životnosť.

Jednoducho povedané, životnosť výstupných referencií bude rovnaká ako životnosť vstupných referencií.

fnnajdlhšie<'a>(x: &'astr, y: &'astr) -> &'astr {
ak x.len() > y.len() { x } inak { y }
}

V najdlhšie Funkcia Rust usudzuje, že životnosť výstupnej referencie je rovnaká ako vstupnej referencie, pretože obe majú rovnaký parameter životnosti 'a.

Pravidlo životnosti vstupu uľahčuje písanie generických funkcií, ktoré berú ako vstup viacero odkazov.

Pravidlo životnosti výstupu

Pravidlo životnosti výstupu určuje, že ak funkcia alebo metóda vráti referenciu, Rust bude predpokladať, že životnosť výstupnej referencie sa líši od životnosti ľubovoľnej vstupnej referencie.

fnprvé_slovo<'a>(s: &'astr) -> &'astr {
 s.split_whitespace().next().unwrap()
}

V tejto funkcii Rust odvodzuje, že životnosť výstupnej referencie sa líši od životnosti vstupnej referencie, pretože split_whitespace() metóda vytvára výstupnú referenciu, ktorá nemá žiadne vstupné referenčné parametre.

Pravidlo Elision of Lifetimes

Pravidlo elision of lifetimes platí, ak funkcia alebo metóda prevezme jeden odkaz alebo vstupný parameter a vráti odkaz. V takom prípade Rust predpokladá, že výstupná referencia má rovnakú životnosť ako vstupná referencia.

fnnajdlhšie<'a>(x: &'astr, y: &str) -> &'astr {
ak x.len() > y.len() { x } inak { y }
}

V tejto funkcii Rust odvodzuje, že životnosť výstupnej referencie je rovnaká ako životnosť vstupnej referencie, pretože vstupná referencia r nemá parameter životnosti. Hrdza eliminuje parameter životnosti pre r a predpokladá, že má rovnakú životnosť ako X.

Toto pravidlo uľahčuje písanie funkcií, ktoré berú jeden vstupný odkaz a vracajú jeden výstupný odkaz.

Vlastnosti a životy

Môžete kombinovať vlastnosti a životnosti, aby ste vytvorili generické funkcie, ktoré fungujú pre typy, ktoré implementujú vlastnosť a majú platnú životnosť.

Tu je vlastnosť a funkcia, ktorá odkazuje na hodnotu, ktorá túto vlastnosť implementuje.

vlastnosťNatiahnuť {
fnnatiahnuť(&seba) -> Reťazec;
}
fnnatiahnuť<'a, T: Natiahnuť>(t: &'a T) -> Reťazec {
 t.to_string()
}

Tu je parameter životnosti 'a zabezpečuje, že referencia t platí po celú dobu životnosti objektu, na ktorý odkazuje. Môžete použiť natiahnuť funkcie s typmi, ktoré implementujú Natiahnuť vlastnosť s platnou životnosťou.

Vlastnosti tvoria základ pre implementáciu OOP konceptov v Rust

Vlastnosti vám umožňujú definovať správanie. Hoci Rust nie je objektovo orientovaný programovací jazyk (OOP), môžete použiť vlastnosti na implementáciu konceptov OOP od zapuzdrenia po dedičnosť, polymorfizmus a abstrakciu.

Implementácia týchto konceptov OOP s vlastnosťami robí vaše programy Rust škálovateľnými, robustnými, udržiavateľnými a efektívnymi.