Научаването на тези две концепции ще ви помогне да засилите разбирането си за това как работи Rust и как можете да внедрите OOP функции.

Характеристиките и продължителността на живота са ключови компоненти на Rust. Можете да използвате черти, за да дефинирате поведение и възможности за типове, които да внедрите. Те са много гъвкави, позволявайки ви да пишете по-генеричен код, да намалите дублирането и да подобрите поддръжката.

Rust използва друг механизъм – времена на живот – за проследяване на собствеността върху променливи във и извън обхвата. Това предотвратява висящи указатели по време на освобождаване на променлива.

Заедно характеристиките и продължителността на живота помагат да се гарантира безопасността на типа, безопасността на паметта и надеждността на кода.

Разбиране на чертите в Rust

Характеристиките са колекции от методи, които други типове могат да прилагат. Чертите са подобни на интерфейси на езици като Java, Go и TypeScript, но по-гъвкави.

Ще използвате Характерна черта ключова дума за дефиниране на черти в Rust, последвана от декларация на сигнатури на метода.

instagram viewer 
Характерна чертаMyTrait {
fnmy_method(&себе си);
}

Кодът дефинира черта с име MyTrait с my_method метод. The & себе си параметър показва, че методът препраща към обекта от имплементиращия тип като негов първи параметър.

След като дефинирате черта, можете да я приложите за вашите персонализирани типове.

Ето как можете да приложите характеристика за вашите типове структури.

структураЛице {
 име: низ,
 възраст: u32,
}
импл Информация за Лице {
fnрезюме(&себе си) {
println!(„Казвам се {} и съм на {} години.“, себе си.име, себе си.възраст);
 }
}

The Лице структурни инструменти Информация, и можете да се обадите на резюме метод върху екземпляри на Лице структура

fnосновен(){
позволявам john = Лице { име: низ::от("Джон"), възраст: 30 };
 john.summary(); // Изход: Казвам се Джон и съм на 30 години.
}

The Джон променливата е екземпляр на Лице структура

The основен извиквания на функции резюме който отпечатва съобщение на конзолата:

Енумите могат да прилагат характеристики. Ето как можете да дефинирате enum с варианти, които изпълняват резюме метод:

изброяванеMyEnum {
 ВариантА,
 ВариантБ,
}
импл Информация за MyEnum {
fnрезюме(&себе си) {
съвпадасебе си {
 MyEnum:: VariantA => {
// реализация за VariantA
 }
 MyEnum:: VariantB => {
// реализация за VariantB
 }
 }
 }
}

Използване на черти за функционални параметри и връщани стойности

Можете да използвате признаци като функционални параметри и връщани стойности. Използването на черти като функционални параметри е удобно за писане на общ код с множество типове.

Ето една функция, която приема параметър от произволен тип, който изпълнява Информация.

fnнаправи нещо(стойност: T) {
 value.summary();
}

The синтаксисът уточнява това T трябва да изпълнява Информация. Можете да се обадите на резюме функция с всяка стойност, която изпълнява Информация.

Живот в Rust

Инструментът за проверка на заеми на Rust анализира програмите и гарантира правилното използване на паметта. в Руст, всяка ценност има собственик който е отговорен за освобождаването на стойността. Кога променливите заемат стойности, те заемат препратка към предадената стойност, но собственикът запазва собствеността.

Продължителността на живота е начин да се гарантира, че заимстваните стойности се използват правилно. Животът е етикет, прикрепен към препратка, описващ колко време е валидна препратката.

В Rust можете да посочите продължителност на живота, като използвате анотация с апостроф:

функция<'а>

При създаването на препратка на препратката се присвоява продължителност на живота, която описва колко дълго е валидна. Ако имате функция, която приема препратка към стойност, времето на живот трябва да е по-дълго от извикването на функцията, за да се гарантира, че стойността е валидна, когато функцията се върне.

Ето пример за спецификация на живота във функция.

fnнаправи нещо<'а>(x: &'аi32) -> &'аi32 {
 х
}
fnосновен() {
позволявам x = 42;
позволявам резултат = do_something(&x);
println!(„Резултатът е: {}“, резултат);
}

В направи нещо функция, на 'а параметърът lifetime показва, че препратката към х е валиден, докато извикването на функцията. Върнатата препратка също е валидна, докато извикването на функцията.

The основен функцията отпечатва резултата чрез предаване на препратка към х променлива в основен функция към конзолата.

Синтаксисът за продължителността на живота може да бъде многословен, но е от съществено значение за безопасността и управлението на паметта. Правилата за трикратно премахване предоставят насоки, които позволяват на Rust да направи извод за живота на препратките в определени ситуации.

Правилото за продължителност на входа

Правилото за продължителност на живота на входа уточнява, че ако функция или метод приема една или повече препратки като входни параметри, Rust приема, че всички препратки имат еднакъв живот.

Просто казано, животът на изходните препратки ще бъде същият като този на входните препратки.

fnнай-дълъг<'а>(x: &'аул, y: &'аул) -> &'аул {
ако x.len() > y.len() { x } друго { y }
}

В най-дълъг функция, Rust заключава, че животът на изходната референция е същият като входната референция, тъй като и двете имат един и същ параметър за продължителност на живота 'а.

Правилото за продължителността на входа улеснява писането на общи функции, които приемат множество препратки като вход.

Правилото за продължителността на изхода

Правилото за изходен живот уточнява, че ако функция или метод върне референция, Rust ще приеме, че животът на изходната референция е различен от живота на всяка входна референция.

fnпърва_дума<'а>(s: &'аул) -> &'аул {
 s.split_whitespace().next().unwrap()
}

В тази функция Rust заключава, че животът на изходната референция е различен от живота на входната референция, тъй като split_whitespace() създава изходна препратка, която не приема входни референтни параметри.

Правилото за премахване на животите

Правилото за премахване на продължителността на живота се прилага, ако функция или метод вземе една препратка или входен параметър и върне препратка. В този случай Rust приема, че изходната референция има същия живот като входната референция.

fnнай-дълъг<'а>(x: &'аул, y: &ул) -> &'аул {
ако x.len() > y.len() { x } друго { y }
}

В тази функция Rust заключава, че животът на изходната референция е същият като живота на входната референция, тъй като входната референция г няма параметър за продължителност на живота. Ръждата премахва параметъра за продължителност на живота г и предполага, че има същия живот като х.

Това правило улеснява писането на функции, които приемат една входна референция и връщат една изходна референция.

Характеристики и продължителност на живота

Можете да комбинирате черти и времена на живот, за да създадете общи функции, които работят за типове, които имплементират черта и имат валиден живот.

Ето черта и функция, която препраща към стойност, която прилага чертата.

Характерна чертаToString {
fnкъм_низ(&себе си) -> низ;
}
fnкъм_низ<'а, T: ToString>(t: &'а T) -> низ {
 t.to_string()
}

Тук параметърът за продължителността на живота 'а гарантира, че справката T е валиден за живота на обекта, към който препраща. Можете да използвате към_низ функция с типове, които имплементират ToString черта с валиден живот.

Характеристиките формират основата за внедряване на OOP концепции в Rust

Чертите ви позволяват да дефинирате поведения. Въпреки че Rust не е обектно-ориентиран език за програмиране (ООП), можете да използвате черти за внедряване на ООП концепции от капсулиране до наследяване, полиморфизъм и абстракция.

Внедряването на тези OOP концепции с характеристики прави вашите програми на Rust мащабируеми, стабилни, поддържаеми и ефективни.