Pochopení Rustových rysů a životů

Vlastnosti a životnost jsou klíčovými součástmi Rust. Vlastnosti můžete použít k definování chování a schopností typů k implementaci. Jsou velmi univerzální a umožňují vám psát generičtější kód, omezit duplicitu a zlepšit udržovatelnost.

Rust používá další mechanismus – životnost – ke sledování vlastnictví proměnných v rozsahu a mimo něj. To zabraňuje visícím ukazatelům během variabilní dealokace.

Vlastnosti a životnost společně pomáhají zajistit bezpečnost typu, bezpečnost paměti a spolehlivost kódu.

Pochopení vlastností v Rustu

Vlastnosti jsou kolekce metod, které mohou implementovat jiné typy. Vlastnosti jsou podobné rozhraní v jazycích, jako je Java, Go a TypeScript, ale flexibilnější.

Budete používat vlastnost klíčové slovo pro definování vlastností v Rustu, následované deklarací podpisů metody.

vlastnostMyTrait {
fnmoje_metoda(&já);
}

Kód definuje vlastnost pojmenovanou

MyTrait s moje_metoda metoda. The &já parametr označuje, že metoda odkazuje na objekt implementačního typu jako svůj první parametr.

Po definování vlastnosti ji můžete implementovat pro své vlastní typy.

Zde je návod, jak můžete implementovat vlastnost pro vaše typy struktur.

strukturovatOsoba {
 název: Tětiva,
 stáří: u32,
}
impl Info pro Osoba {
fnsouhrn(&já) {
println!("Jmenuji se {} a je mi {} let.", já.název, já.stáří);
 }
}

The Osoba strukturní nářadí Infoa můžete zavolat na souhrn metoda na příkladech Osoba strukturovat.

fnhlavní(){
nechat john = Osoba { jméno: Tětiva::z("John"), věk: 30 };
 john.summary(); // Výstup: Jmenuji se John a je mi 30 let.
}

The John proměnná je instancí třídy Osoba strukturovat.

The hlavní volání funkcí souhrn který vypíše zprávu do konzole:

Enumové mohou implementovat vlastnosti. Zde je návod, jak můžete definovat výčet s variantami, které implementují souhrn metoda:

enumMyEnum {
 Varianta A,
 VariantaB,
}
impl Info pro MyEnum {
fnsouhrn(&já) {
zápasjá {
 MyEnum:: VariantaA => {
// implementace pro VariantA
 }
 MyEnum:: VariantB => {
// implementace pro VariantB
 }
 }
 }
}

Použití vlastností pro funkční parametry a návratové hodnoty

Vlastnosti můžete použít jako parametry funkce a návratové hodnoty. Použití vlastností jako parametrů funkce je užitečné pro psaní obecného kódu s více typy.

Zde je funkce, která přebírá parametr jakéhokoli typu, který implementuje Info.

fndělej něco(hodnota: T) {
 hodnota.souhrn();
}

The syntaxe to specifikuje T musí implementovat Info. Můžete zavolat na souhrn funkce s libovolnou hodnotou, která implementuje Info.

Životy v Rustu

Rustův nástroj pro kontrolu výpůjček analyzuje programy a zajišťuje správné využití paměti. V Rustu, každá hodnota má svého vlastníka která je zodpovědná za přidělení hodnoty. Když proměnné si vypůjčují hodnoty, vypůjčí si odkaz na předanou hodnotu, ale vlastník si ponechává vlastnictví.

Životnost je způsob, jak zajistit správné použití vypůjčených hodnot. Životnost je štítek připojený k referenci, popisující, jak dlouho je reference platná.

V Rustu můžete určit životnost pomocí apostrofové anotace:

func<'A>

Při vytváření reference je referenci přiřazena životnost, která popisuje, jak dlouho je platná. Pokud máte funkci, která přebírá odkaz na hodnotu, musí být životnost delší než volání funkce, aby bylo zajištěno, že hodnota je platná, když se funkce vrátí.

Zde je příklad specifikace životnosti ve funkci.

fndělej něco<'A>(x: &'Ai32) -> &'Ai32 {
 X
}
fnhlavní() {
nechat x = 42;
nechat výsledek = něco udělej(&x);
println!("Výsledek je: {}", výsledek);
}

V dělej něco funkce, 'A životnost parametr označuje, že odkaz na X je platný po dobu volání funkce. Vrácený odkaz je také platný po dobu volání funkce.

The hlavní funkce vypíše výsledek předáním odkazu na X proměnná v hlavní funkce do konzole.

Syntaxe životnosti může být podrobná, ale je nezbytná pro bezpečnost a správu paměti. Pravidla pro eliminaci tří životností poskytují pokyny, které umožňují Rustovi v určitých situacích odvodit životnost odkazů.

Pravidlo životnosti vstupu

Pravidlo životnosti vstupu určuje, že pokud funkce nebo metoda bere jeden nebo více odkazů jako vstupní parametry, Rust předpokládá, že všechny odkazy mají stejnou životnost.

Jednoduše řečeno, životnost výstupních referencí bude stejná jako životnost vstupních referencí.

fnnejdelší<'A>(x: &'Astr, y: &'Astr) -> &'Astr {
-li x.len() > y.len() { x } jiný {y}
}

V nejdelší funkce, Rust vyvozuje, že životnost výstupní reference je stejná jako vstupní reference, protože obě mají stejný parametr životnosti 'A.

Pravidlo životnosti vstupu usnadňuje psaní generických funkcí, které berou jako vstup více odkazů.

Pravidlo životnosti výstupu

Pravidlo životnosti výstupu určuje, že pokud funkce nebo metoda vrátí odkaz, Rust bude předpokládat, že životnost výstupní reference se liší od životnosti jakékoli vstupní reference.

fnprvní slovo<'A>(s: &'Astr) -> &'Astr {
 s.split_whitespace().next().unwrap()
}

V této funkci Rust vyvozuje, že životnost výstupní reference se liší od životnosti vstupní reference, protože split_whitespace() metoda vytvoří výstupní referenci, která nemá žádné vstupní referenční parametry.

Pravidlo Elise of Lifetimes

Pravidlo elision of lifetimes se použije, pokud funkce nebo metoda vezme jeden odkaz nebo vstupní parametr a vrátí odkaz. V takovém případě Rust předpokládá, že výstupní reference má stejnou životnost jako vstupní reference.

fnnejdelší<'A>(x: &'Astr, y: &str) -> &'Astr {
-li x.len() > y.len() { x } jiný {y}
}

V této funkci Rust vyvozuje, že životnost výstupní reference je stejná jako životnost vstupní reference, protože vstupní reference y nemá parametr životnosti. Rust eliminuje parametr životnosti pro y a předpokládá, že má stejnou životnost jako X.

Toto pravidlo usnadňuje psaní funkcí, které berou jeden vstupní odkaz a vracejí jeden výstupní odkaz.

Vlastnosti a životy

Můžete kombinovat vlastnosti a doby trvání a vytvářet obecné funkce, které fungují pro typy, které implementují vlastnost a mají platnou životnost.

Zde je vlastnost a funkce, která odkazuje na hodnotu, která tuto vlastnost implementuje.

vlastnostToString {
fndo_řetězce(&já) -> Tětiva;
}
fndo_řetězce<'A, T: ToString>(t: &'A T) -> Tětiva {
 t.to_string()
}

Zde je parametr životnosti 'A zajišťuje, že odkaz t je platný po dobu životnosti objektu, na který odkazuje. Můžete použít do_řetězce funkce s typy, které implementují ToString vlastnost s platnou životností.

Vlastnosti tvoří základ pro implementaci OOP konceptů v Rustu

Vlastnosti vám umožňují definovat chování. Přestože Rust není objektově orientovaný programovací jazyk (OOP), můžete pomocí vlastností implementovat koncepty OOP od zapouzdření po dědičnost, polymorfismus a abstrakci.

Implementace těchto konceptů OOP s vlastnostmi činí vaše programy Rust škálovatelnými, robustními, udržovatelnými a efektivními.