Езиците за програмиране се различават по начина, по който обработват паметта и налагат правилата за управление на паметта. Go и Python използват събирачи на отпадъци, така че разработчиците могат да се съсредоточат върху писането на код. C и C++ дават на програмистите отговорност за управление на паметта на по-ниско ниво.
Rust третира управлението на паметта по различен начин, използвайки концепции, които нарича собственост и заемане. Той използва „проверка на заеми“, за да наложи ефективно безопасността на паметта.
Какво е собственост?
Собствеността е функция и конвенция на Rust, която помага да се гарантира безопасността на паметта на програмите без събирач на отпадъци. Това е друг начин за справяне проблемът с изтичането на памет във вашия код.
Компилаторът Rust проверява дали дадена програма се подчинява на правилата за собственост по време на компилация. Ако програмата следва тези правила, тя може да работи. Ако не го направи, компилаторът отказва да създаде изпълним файл.
Rust проверява правилата за собственост с помощта на
чек назаем. Инструментът за проверка на заеми проверява модела на собственост и решава дали стойност в паметта (стек или купчина) е извън обхвата или не. Ако дадена стойност е извън своя обхват, тя не е достъпна за други части на програмата, освен ако не е заета.Правилата за собственост
В Rust всяка променлива притежава стойността, с която е инициализирана, и може да има само един собственик. След като собственикът е извън обхвата, стойността се премахва. Важно е да разберете подробностите на правилата за собственост.
Първото правило за собственост е, че всяка променлива притежава своята инициализирана стойност.
позволявам собственик = низ::от("един");
The собственик променливата по-горе притежава низа един и за разлика от езици като Python и Go, тази стойност ще бъде премахната при преназначаване на променлива.
Второто правило за собственост е, че две променливи не могат да сочат към едно и също място в паметта; всяка стойност може да има само един собственик.
позволявам нов_собственик = собственик;
The нов_собственик променливата вече притежава стойността, съхранена в местоположението на паметта на собственик променлива. Ако се опитате да използвате собственик променлива, компилаторът ще се паникьоса и ще откаже да генерира изпълним файл.
В повечето езици, които използват събирачи на отпадъци, две променливи могат да сочат към едно и също място в паметта. Ето пример за еквивалентен JavaScript код:
позволявам owner = "собственик";
позволявам нов_собственик = собственик;
конзола.log (нов_собственик);
Изпълнението на кода на JavaScript по-горе работи без грешки и ако направите същото в Go или Python, вашата програма също ще работи без грешки.
Третото правило за собственост е, че щом дадена променлива е извън декларирания обхват, стойността се изтрива и паметта се освобождава.
// променлива в отделен обхват
{
позволявам пример = низ::from("Ето нов обхват");
}
печат!("{}", пример)
Нямате достъп до пример променлива извън своя обхват; опитвайки се да го направите, компилаторът ще изпадне в паника.
Собственост във функциите
Когато подадете стойност на функция като аргумент, функцията има достъп до тази променлива, въпреки че не е декларирана в нейния обхват:
fnпринтер(стойност: низ) -> низ {
връщане стойност
}fnосновен() {
позволявам x = низ::from("Отпечатва стойност"); // x притежава стойността на низа
// собствеността се премества към функцията за принтер тук
печат!(„{} The Резултат на Printing X е, че то -:", принтер (x));
}
Функцията има достъп до тази променлива, защото Rust премества собствеността върху нея към функцията по време на компилиране.
Може би си мислите, че все още е възможно да използвате променливата по-късно в първоначалния й обхват:
fnпринтер(стойност: низ) -> низ {
връщане стойност
}fnосновен() {
позволявам x = низ::from("Отпечатва стойност");
печат!(„{} The Резултат на Printing x е, че то -:", принтер (x));
// Опит за използване на променливата, след като собствеността върху нейната стойност е прехвърлена
println!(„{} не трябва да е достъпен“, x)
}
Но ако опитате това, компилаторът ще се паникьоса и ще откаже да създаде изпълним файл:
Rust дава приоритет на повторното използване на кода
Повторната употреба на кода е основна практика, но за да практикувате повторната употреба на кода, трябва да разберете правилата за собственост на Rust.
Rust е много гъвкав език за програмиране. Той предоставя концепции като заемане, преместване, копиране и клониране на собственост за повторно използване на променливи.
