De eigenschappen en levensduur van Rust begrijpen

Eigenschappen en levensduur zijn de belangrijkste componenten van Rust. U kunt eigenschappen gebruiken om gedragingen en mogelijkheden te definiëren voor te implementeren typen. Ze zijn zeer veelzijdig, waardoor u meer generieke code kunt schrijven, duplicatie kunt verminderen en de onderhoudbaarheid kunt verbeteren.

Rust gebruikt een ander mechanisme - levens - om het eigendom van variabelen binnen en buiten het bereik te volgen. Dit voorkomt bungelende wijzers tijdens variabele deallocatie.

Eigenschappen en levensduur zorgen samen voor typeveiligheid, geheugenveiligheid en codebetrouwbaarheid.

Eigenschappen in roest begrijpen

Traits zijn verzamelingen methoden die andere typen kunnen implementeren. Eigenschappen zijn vergelijkbaar met interfaces in talen zoals Java, Go en TypeScript maar flexibeler.

Je gebruikt de karaktereigenschap trefwoord om kenmerken in Rust te definiëren, gevolgd door een verklaring van methodehandtekeningen.

karaktereigenschapMijnTrait {
fnmijn_methode(&zelf);
}

De code definieert een eigenschap met de naam MijnTrait met een mijn_methode methode. De &zelf parameter geeft aan dat de methode verwijst naar het object van het implementatietype als eerste parameter.

Nadat u een eigenschap hebt gedefinieerd, kunt u deze implementeren voor uw aangepaste typen.

Hier leest u hoe u een eigenschap voor uw structuurtypen kunt implementeren.

structuurPersoon {
 naam: Snaar,
 leeftijd: u32,
}
impl Info voor Persoon {
fnsamenvatting(&zelf) {
println!("Mijn naam is {} en ik ben {} jaar oud.", zelf.naam, zelf.leeftijd);
 }
}

De Persoon struct implementeert Info, en u kunt bellen met de samenvatting methode op instanties van de Persoon structuur.

fnvoornaamst(){
laten john = Persoon { naam: Snaar::van("John"), leeftijd: 30 };
 john.samenvatting(); // Output: Mijn naam is John en ik ben 30 jaar oud.
}

De John variabele is een instantie van de Persoon structuur.

De voornaamst functie oproepen samenvatting die een bericht naar de console afdrukt:

Opsommingen kunnen eigenschappen implementeren. Hier leest u hoe u een opsomming kunt definiëren met varianten die de samenvatting methode:

opsommingMijnEnum {
 variantA,
 variantB,
}
impl Info voor MijnEnum {
fnsamenvatting(&zelf) {
overeenkomstzelf {
 MijnEnum:: VariantA => {
// implementatie voor VariantA
 }
 MijnEnum:: VariantB => {
// implementatie voor VariantB
 }
 }
 }
}

Eigenschappen gebruiken voor functieparameters en retourwaarden

U kunt kenmerken gebruiken als functieparameters en retourwaarden. Het gebruik van eigenschappen als functieparameters is handig voor het schrijven van generieke code met meerdere typen.

Hier is een functie die een parameter van elk type neemt die implementeert Info.

fndoe iets(waarde: T) {
 waarde.samenvatting();
}

De syntaxis specificeert dat T moet uitvoeren Info. U kunt bellen naar de samenvatting functie met elke waarde die wordt geïmplementeerd Info.

Levens in Roest

De tool voor het controleren van leningen van Rust analyseert programma's en zorgt voor correct geheugengebruik. in roest, elke waarde heeft een eigenaar die verantwoordelijk is voor het vrijgeven van de waarde. Wanneer variabelen lenen waarden, ze lenen een verwijzing naar de doorgegeven waarde, maar de eigenaar behoudt het eigendom.

Lifetimes zijn een manier om ervoor te zorgen dat geleende waarden correct worden gebruikt. Een levensduur is een label dat aan een referentie is bevestigd en beschrijft hoe lang de referentie geldig is.

In Rust kun je een levensduur specificeren met behulp van een apostrof-annotatie:

func<'A>

Bij het maken van een referentie krijgt de referentie een levensduur toegewezen die beschrijft hoe lang deze geldig is. Als u een functie hebt die de verwijzing naar een waarde neemt, moet de levensduur langer zijn dan de functieaanroep om ervoor te zorgen dat de waarde geldig is wanneer de functie terugkeert.

Hier is een voorbeeld van levenslange specificatie in een functie.

fndoe iets<'A>(x: &'Ai32) -> &'Ai32 {
 X
}
fnvoornaamst() {
laten x= 42;
laten resultaat = doe_iets(&x);
println!("Het resultaat is: {}", resultaat);
}

In de doe iets functie, de 'A levensduur parameter geeft aan dat de verwijzing naar X is geldig zolang de functieaanroep. De geretourneerde referentie is ook geldig zolang de functieaanroep.

De voornaamst functie drukt het resultaat af door een verwijzing door te geven naar de X variabele in de voornaamst functie naar de console.

De levenslange syntaxis kan uitgebreid zijn, maar is essentieel voor veiligheid en geheugenbeheer. Elision-regels voor drie levenstijden bieden richtlijnen waarmee Rust in bepaalde situaties de levensduur van referenties kan afleiden.

De invoerlevensduurregel

De regel voor invoerlevensduur specificeert dat als een functie of methode een of meer referenties als invoerparameters gebruikt, Rust ervan uitgaat dat alle referenties dezelfde levensduur hebben.

Simpel gezegd, de levensduur van uitvoerreferenties is dezelfde als die van de invoerreferenties.

fnlangste<'A>(x: &'Astr, y: &'Astr) -> &'Astr {
als x.len() > y.len() { x } anders { j }
}

In de langste functie leidt Rust af dat de levensduur van de uitvoerreferentie hetzelfde is als de invoerreferentie omdat ze beide dezelfde levensduurparameter hebben 'A.

De invoerlevensduurregel maakt het schrijven van generieke functies die meerdere referenties als invoer gebruiken eenvoudig.

De uitvoerlevensduurregel

De regel voor de levensduur van de uitvoer specificeert dat als een functie of methode een referentie retourneert, Rust ervan uitgaat dat de levensduur van de uitvoerreferentie verschilt van de levensduur van elke invoerreferentie.

fneerste woord<'A>(s: &'Astr) -> &'Astr {
 s.split_whitespace().next().uitpakken()
}

In deze functie leidt Rust af dat de levensduur van de uitvoerreferentie verschilt van de levensduur van de invoerreferentie omdat de split_whitespace() methode creëert een uitvoerreferentie die geen invoerreferentieparameters nodig heeft.

De Elision of Lifetimes-regel

De regel voor het weglaten van levenstijden is van toepassing als een functie of methode één referentie of invoerparameter gebruikt en een referentie retourneert. In dat geval gaat Rust ervan uit dat de uitgangsreferentie dezelfde levensduur heeft als de ingangsreferentie.

fnlangste<'A>(x: &'Astr, y: &str) -> &'Astr {
als x.len() > y.len() { x } anders { j }
}

In deze functie leidt Rust af dat de levensduur van de uitgangsreferentie gelijk is aan de levensduur van de ingangsreferentie omdat de ingangsreferentie j heeft geen levenslange parameter. Roest verdwijnt de levensduurparameter voor j en gaat ervan uit dat het dezelfde levensduur heeft als X.

Deze regel maakt het gemakkelijker om functies te schrijven die één invoerreferentie gebruiken en één uitvoerreferentie retourneren.

Eigenschappen en levens

U kunt eigenschappen en levensduur combineren om generieke functies te creëren die werken voor typen die een eigenschap implementeren en een geldige levensduur hebben.

Hier is een eigenschap en een functie die verwijst naar een waarde die de eigenschap implementeert.

karaktereigenschapToString {
fnnaar_tekenreeks(&zelf) -> Snaar;
}
fnnaar_tekenreeks<'A, T: ToString>(t: &'A T) -> Snaar {
 t.to_string()
}

Hier de levensduurparameter 'A zorgt ervoor dat de referentie T is geldig voor de levensduur van het object waarnaar het verwijst. U kunt de naar_tekenreeks functie met typen die de ToString eigenschap met een geldige levensduur.

Eigenschappen vormen de basis voor het implementeren van OOP-concepten in Rust

Met eigenschappen kun je gedrag definiëren. Hoewel Rust geen objectgeoriënteerde programmeertaal (OOP) is, kun je eigenschappen gebruiken om OOP-concepten te implementeren, van inkapseling tot overerving, polymorfisme en abstractie.

Door deze OOP-concepten met eigenschappen te implementeren, worden uw Rust-programma's schaalbaar, robuust, onderhoudbaar en efficiënt.