Forstå rustens egenskaper og levetid

Egenskaper og levetid er nøkkelkomponenter i rust. Du kan bruke egenskaper til å definere atferd og evner for typer å implementere. De er veldig allsidige, slik at du kan skrive mer generisk kode, redusere duplisering og forbedre vedlikeholdsevnen.

Rust bruker en annen mekanisme – levetider – for å spore eierskap til variabler innenfor og utenfor omfanget. Dette forhindrer hengende pekere under variabel deallokering.

Sammen bidrar egenskaper og levetider til å sikre typesikkerhet, minnesikkerhet og kodepålitelighet.

Forstå egenskaper i rust

Egenskaper er samlinger av metoder som andre typer kan implementere. Egenskaper ligner på grensesnitt på språk som Java, Go og TypeScript, men mer fleksible.

Du vil bruke trekk nøkkelord for å definere egenskaper i Rust, etterfulgt av en erklæring om metodesignaturer.

trekkMyTrait {
fnmin_metode(&selv-);
}

Koden definerer en egenskap som heter

MyTrait med en min_metode metode. De &selv parameter indikerer at metoden refererer til objektet til implementeringstypen som dens første parameter.

Etter å ha definert en egenskap, kan du implementere den for dine egendefinerte typer.

Her er hvordan du kan implementere en egenskap for strukturtypene dine.

strukturPerson {
 Navn: String,
 alder: u32,
}
impl Info til Person {
fnsammendrag(&selv-) {
println!("Mitt navn er {} og jeg er {} år gammel.", selv-.Navn, selv-.alder);
 }
}

De Person struktur redskaper Info, og du kan ringe sammendrag metode på forekomster av Person struktur.

fnhoved-(){
la john = Person {navn: String::fra("John"), alder: 30 };
 john.summary(); // Utgang: Jeg heter John, og jeg er 30 år gammel.
}

De john variabel er en forekomst av Person struktur.

De hoved- funksjonsanrop sammendrag som skriver ut en melding til konsollen:

Enums kan implementere egenskaper. Her er hvordan du kan definere en enum med varianter som implementerer sammendrag metode:

enumMyEnum {
 VariantA,
 VariantB,
}
impl Info til MyEnum {
fnsammendrag(&selv-) {
kampselv- {
 MyEnum:: VariantA => {
// implementering for VariantA
 }
 MyEnum:: VariantB => {
// implementering for VariantB
 }
 }
 }
}

Bruke egenskaper for funksjonsparametre og returverdier

Du kan bruke egenskaper som funksjonsparametere og returverdier. Å bruke egenskaper som funksjonsparametere er nyttig for å skrive generisk kode med flere typer.

Her er en funksjon som tar en parameter av enhver type som implementerer Info.

fngjør noe(verdi: T) {
 verdi.sammendrag();
}

De syntaks spesifiserer det T må gjennomføre Info. Du kan ringe til sammendrag funksjon med hvilken som helst verdi som implementerer Info.

Levetider i Rust

Rusts lånesjekkverktøy analyserer programmer og sikrer riktig minnebruk. I Rust, hver verdi har en eier som er ansvarlig for å fordele verdien. Når variabler låne verdier, låner de en referanse til den passerte verdien, men eieren beholder eierskapet.

Levetider er en måte å sikre at lånte verdier brukes riktig. En levetid er en etikett festet til en referanse, som beskriver hvor lenge referansen er gyldig.

I Rust kan du spesifisere en levetid ved å bruke en apostrofkommentar:

func<'en>

Når du oppretter en referanse, blir referansen tildelt en levetid som beskriver hvor lenge den er gyldig. Hvis du har en funksjon som tar referansen til en verdi, må levetiden være lengre enn funksjonskallet for å sikre at verdien er gyldig når funksjonen returnerer.

Her er et eksempel på levetidsspesifikasjoner i en funksjon.

fngjør noe<'en>(x: &'eni32) -> &'eni32 {
 x
}
fnhoved-() {
la x = 42;
la resultat = gjør_noe(&x);
println!("Resultatet er: {}", resultat);
}

I gjør noe funksjon, den 'en levetidsparameter indikerer at referansen til x er gyldig så lenge funksjonsanropet. Den returnerte referansen er også gyldig så lenge funksjonskallet.

De hoved- funksjonen skriver ut resultatet ved å sende en referanse til x variabel i hoved- funksjon til konsollen.

Livstidssyntaksen kan være detaljert, men den er viktig for sikkerhet og minnehåndtering. Elisjonsregler for tre levetider gir retningslinjer som lar Rust utlede levetiden til referanser i visse situasjoner.

Levetidsregelen for input

Livstidsregelen for input spesifiserer at hvis en funksjon eller metode tar en eller flere referanser som inputparametere, antar Rust at alle referanser har samme levetid.

Enkelt sagt vil levetiden til utdatareferansene være den samme som for inngangsreferansene.

fnlengste<'en>(x: &'enstr, y: &'enstr) -> &'enstr {
hvis x.len() > y.len() { x } ellers {y}
}

I lengste funksjon, utleder Rust at levetiden til utgangsreferansen er den samme som inngangsreferansen fordi de begge har samme levetidsparameter 'en.

Levetidsregelen for input gjør det enkelt å skrive generiske funksjoner som tar flere referanser som input.

Utgangslevetidsregelen

Utgangslevetidsregelen spesifiserer at hvis en funksjon eller metode returnerer en referanse, vil Rust anta at levetiden til utdatareferansen er forskjellig fra levetiden til en hvilken som helst inngangsreferanse.

fnførste_ord<'en>(s: &'enstr) -> &'enstr {
 s.split_whitespace().next().unwrap()
}

I denne funksjonen utleder Rust at levetiden til utgangsreferansen er forskjellig fra levetiden til inngangsreferansen fordi split_whitespace() metoden oppretter en utdatareferanse som ikke tar noen inndatareferanseparametere.

Elision of Lifetimes-regelen

Elision of lifetimes-regelen gjelder hvis en funksjon eller metode tar én referanse eller inngangsparameter og returnerer en referanse. I så fall antar Rust at utgangsreferansen har samme levetid som inngangsreferansen.

fnlengste<'en>(x: &'enstr, y: &str) -> &'enstr {
hvis x.len() > y.len() { x } ellers {y}
}

I denne funksjonen utleder Rust at levetiden til utgangsreferansen er den samme som levetiden til inngangsreferansen fordi inngangsreferansen y har ingen levetidsparameter. Rust elides levetidsparameteren for y og antar at den har samme levetid som x.

Denne regelen gjør det lettere å skrive funksjoner som tar én inngangsreferanse og returnerer én utgangsreferanse.

Egenskaper og levetider

Du kan kombinere egenskaper og levetider for å lage generiske funksjoner som fungerer for typer som implementerer en egenskap og har en gyldig levetid.

Her er en egenskap og en funksjon som refererer til en verdi som implementerer egenskapen.

trekkToString {
fntil_streng(&selv-) -> String;
}
fntil_streng<'en, T: ToString>(t: &'en T) -> String {
 t.to_string()
}

Her er levetidsparameteren 'en sikrer at referansen t er gyldig for levetiden til objektet den refererer til. Du kan bruke til_streng funksjon med typer som implementerer ToString egenskap som har en gyldig levetid.

Egenskaper danner grunnlaget for implementering av OOP-konsepter i rust

Egenskaper gjør at du kan definere atferd. Selv om Rust ikke er et objektorientert programmeringsspråk (OOP), kan du bruke egenskaper til å implementere OOP-konsepter fra innkapsling til arv, polymorfisme og abstraksjon.

Implementering av disse OOP-konseptene med egenskaper gjør Rust-programmene dine skalerbare, robuste, vedlikeholdbare og effektive.