Forstå Rusts generiske typer

Det er alltid nivåer av usikkerhet under utvikling av applikasjoner, noe som kan føre til feil, spesielt hvis funksjonene dine aksepterer spesifikke typer argumenter. For å redusere feil på grunn av usikkerhet kan du bruke Generics. Generikk gir funksjonalitet for å lage klasser, funksjoner og datastrukturer for arbeid med forskjellige typer.

Ved å bruke generikk kan du opprette og definere algoritmer og datastrukturer som kan operere på flere typer uten å skrive kompleks kode og separate implementeringer for hver type. Generikk forbedrer kodegjenbrukbarhet og effektivitet samtidig som typesikkerhet og ytelse opprettholdes.

Bruke generiske typer i rust

Rusts generiske type kan samvirke med andre rustdatatyper. Du definerer generiske typer med vinkelparenteser (<>), etterfulgt av to eller flere parametere.

Her er en generisk strukturdefinisjon som tar to generiske typeparametere:

strukturPunkt {
// T og U er generiske typeparametere som x- og y-feltene vil 
// anta ved instansiering
 x: T,
 y: U,
}

I Punkt struktur, T, og U er generiske typeparametere.

Du kan erstatte de generiske typeparameterne med en hvilken som helst datatype ved instansiering:

fnhoved-() {
la mitt_punkt = Punkt { x: String::fra("Hallo"), y: String::fra("verden") };
println!(
"X-verdien til mitt_punkt er {} og y-verdien er {}.",
 mitt_punkt.x,
 mitt_punkt.y
 );
}

De mitt poeng variabel er en forekomst av Punkt struct initialisert med strengtyper. Rust-kompilatoren utleder konkrete typer T og U basert på verdiene ved instansiering.

Egenskapsgrenser for generiske typer

Generiske rusttyper kan bruke egenskapsgrenser for å sikre typesikkerhet. Egenskaper er samlinger av metoder som typer kan implementere for å vise visse atferd definert for egenskapen.

Egenskapsgrenser spesifiserer at en generisk type må implementere en eller flere egenskaper.

Her er et eksempel på en generisk funksjon som returnerer den største av to verdier med en egenskapsbinding som sikrer at typene som sammenlignes implementerer egenskapen:

// Maksimum er en egenskap som definerer en metode for å evaluere maksimalt to
// typer
trekkMaksimum {
fnmaks(selv-, annet: Selv) -> Selv;
}
// Implementerer "Maksimum"-egenskapen for alle typer som implementerer
// `PartialOrd`-trekk.
implPartialOrd> Maksimum til T {
fnmaks(selv-, annet: Selv) -> Selv {
// returner `selv` hvis det er større enn `annet`; ellers, returner
// `annet.`
hvisselv- > andre {
selv-
 } ellers {
 annen
 }
 }
}
fnhoved-() {
la a = 5;
la b = 10;
la største = Maksimum:: maks (a, b);
println!("Den største verdien er {}", størst);
}

De Maksimum egenskap har en maks metode som returnerer den største av to verdier av samme type. Enhver type som implementerer PartialOrd egenskap implementerer Maksimum trekk.

De maks metoden tar to verdier av Selv type – refererer til typen som implementerer Maksimum egenskap – og sammenligner verdiene.

De hoved- funksjonen sammenligner to variabler ved å bruke maks metode og trykker den største.

Begrensninger for generiske typer

Begrensninger ligner på egenskapsgrenser, men de lar deg spesifisere tilleggskrav for typer du bruker som typeparametere.

Hvis du vil lage en generisk funksjon som godtar typer for strengkonvertering, kan du bruke en begrensning for å sikre at typeparameteren implementerer en egenskap.

// ToString er en egenskap med en strengkonverteringsmetode
trekkToString {
fntil_streng(&selv-) -> String;
}
// to_string er en generisk funksjon som tar en verdi av en hvilken som helst type som
// implementerer ToString-trekket
fntil_strengToString>(verdi: T) -> String {
 verdi.til_streng()
}

De til_streng verdi parameteren må implementere ToString egenskap, som sikrer at du kan konvertere verdier av type T å strenge med til_streng metode.

Generiske typer er nyttige for å jobbe med egenskaper

Generiske rusttyper er kraftige, og det er områder for forbedring. Et kritisk fokusområde er å forbedre ytelsen til generisk kode. For øyeblikket kan Rusts typesystem pålegge generisk kode overhead, og redusere ytelsen.

Generiske typer er gunstige for å jobbe med egenskaper. Ved å bruke generiske typer kan du lage egenskapsobjekter som fungerer med alle typer som implementerer en egenskap for å gjøre metodene dine mer fleksible.