Programmeringsspråk er forskjellige i hvordan de håndterer minne og håndhever regler for minneadministrasjon. Go og Python ansetter søppelsamlere, slik at utviklere kan fokusere på å skrive kode. C og C++ gir programmerere ansvar for å administrere minne på et lavere nivå.
Rust behandler minnehåndtering annerledes ved å bruke konsepter det kaller eierskap og lån. Den bruker en "lånesjekker" for å håndheve minnesikkerheten effektivt.
Hva er eierskap?
Eierskap er en funksjon og konvensjon av Rust som bidrar til å sikre minnesikkerheten til programmer uten en søppeloppsamler. Det er en annen måte å takle på problemet med minnelekkasjer i koden din.
Rust-kompilatoren sjekker om et program overholder eierskapsreglene på kompileringstidspunktet. Hvis programmet følger disse reglene, kan det kjøres. Hvis den ikke gjør det, nekter kompilatoren å produsere en kjørbar fil.
Rust verifiserer eierskapsreglene ved å bruke låne brikke. Lånekontrollen verifiserer eierskapsmodellen og bestemmer om en verdi i minnet (
stabel eller haug) er utenfor omfanget eller ikke. Hvis en verdi er utenfor omfanget, er den ikke tilgjengelig for andre deler av programmet med mindre den er lånt.Eierskapsreglene
I Rust eier hver variabel verdien den er initialisert med, og det kan bare være én eier. Når eieren er utenfor omfanget, faller verdien. Det er viktig å forstå detaljene i eierskapsreglene.
Den første eierskapsregelen er at hver variabel eier sin initialiserte verdi.
la eier = String::fra("en");
De Eieren variabelen ovenfor eier strengen en og, i motsetning til språk som Python og Go, vil denne verdien bli droppet ved variabel omtilordning.
Den andre eierskapsregelen er at to variabler ikke kan peke til samme minneplassering; hver verdi kan bare ha én eier.
la ny_eier = eier;
De ny_eier variabelen eier nå verdien som er lagret på minnestedet til Eieren variabel. Hvis du prøver å bruke Eieren variabel, vil kompilatoren få panikk, og den vil nekte å generere en kjørbar fil.
På de fleste språk som bruker søppelsamlere, kan to variabler peke til samme minneplassering. Her er et eksempel på tilsvarende JavaScript-kode:
la eier = "eier";
la ny_eier = eier;
konsoll.log (ny_eier);
Å kjøre JavaScript-koden ovenfor fungerer uten feil, og hvis du gjør det samme i Go eller Python, vil programmet også fungere uten feil.
Den tredje eierskapsregelen er at når en variabel er utenfor det deklarerte omfanget, blir verdien droppet, og minnet blir deallokert.
// en variabel i et eget omfang
{
la eksempel = String::from("Her er et nytt omfang");
}
skrive ut!("{}", eksempel)
Du får ikke tilgang til eksempel variabel utenfor omfanget; prøver å gjøre det vil føre til at kompilatoren får panikk.
Eierskap i funksjoner
Når du sender en verdi til en funksjon som et argument, kan funksjonen få tilgang til den variabelen selv om den ikke ble deklarert i sitt omfang:
fnskriver(verdi: String) -> String {
komme tilbake verdi
}fnhoved-() {
la x = String::from("Skriver ut en verdi"); // x eier strengverdien
// eierskap flyttes til skriverfunksjonen her
skrive ut!("{} Den Resultat av utskrift X er at det -:", skriver (x));
}
Funksjonen kan få tilgang til den variabelen fordi Rust flytter eierskapet til den til funksjonen på kompileringstidspunktet.
Du tror kanskje det fortsatt er mulig å bruke variabelen senere i det opprinnelige omfanget:
fnskriver(verdi: String) -> String {
komme tilbake verdi
}fnhoved-() {
la x = String::from("Skriver ut en verdi");
skrive ut!("{} Den Resultat av Utskrift x er at det -:", skriver (x));
// Prøver å bruke variabelen etter at eierskapet til verdien er overført
println!("{} skal ikke være tilgjengelig", x)
}
Men hvis du prøver dette, vil kompilatoren få panikk og nekte å produsere en kjørbar fil:
Rust prioriterer gjenbruk av kode
Gjenbruk av kode er en viktig praksis, men for å praktisere gjenbruk av kode må du forstå Rusts eierskapsregler.
Rust er et veldig fleksibelt programmeringsspråk. Det gir konsepter som lån, flytting, kopiering og kloning av eierskap for variabel gjenbruk.
