Reducer dit rustkodefodaftryk og øg dets robusthed med generiske typer.

Der er altid niveauer af usikkerhed under udvikling af applikationer, hvilket kan føre til fejl, især hvis dine funktioner accepterer specifikke typer argumenter. For at reducere fejl på grund af usikkerheder kan du bruge Generics. Generics giver funktionalitet til at skabe klasser, funktioner og datastrukturer til at arbejde med forskellige typer.

Ved hjælp af generiske artikler kan du oprette og definere algoritmer og datastrukturer, der kan fungere på flere typer uden at skrive kompleks kode og separate implementeringer for hver type. Generics forbedrer kodegenanvendelighed og effektivitet, samtidig med at typens sikkerhed og ydeevne bibeholdes.

Brug af generiske typer i rust

Rusts generiske type kan interagere med andre rustdatatyper. Du definerer generiske typer med vinkelparenteser (<>), efterfulgt af to eller flere parametre.

Her er en generisk struktur definition der tager to generiske typeparametre:

strukturPunkt
 {
// T og U er generiske typeparametre, som x- og y-felterne vil 
// antage ved instansiering
 x: T,
 y: U,
}

I den Punkt struktur, T, og U er generiske typeparametre.

Du kan erstatte de generiske typeparametre med enhver datatype ved instansiering:

fnvigtigste() {
lade mit_punkt = Punkt { x: Snor::fra("Hej"), y: Snor::fra("verden") };
println!(
"X-værdien af ​​mit_punkt er {} og y-værdien er {}.",
 mit_punkt.x,
 mit_punkt.y
 );
}

Det mit_punkt variabel er en forekomst af Punkt struct initialiseret med strengtyper. Rust compileren udleder de konkrete typer af T og U baseret på værdierne ved instansiering.

Egenskabsgrænser for generiske typer

Generiske rusttyper kan bruge egenskabsgrænser for at sikre typesikkerhed. Træk er samlinger af metoder, som typer kan implementere for at udvise bestemte adfærd, der er defineret for træk.

Egenskabsgrænser angiver, at en generisk type skal implementere en eller flere egenskaber.

Her er et eksempel på en generisk funktion, der returnerer den største af to værdier med en egenskabsbundet, der sikrer, at de sammenlignede typer implementerer egenskaben:

// Maksimum er en egenskab, der definerer en metode til at vurdere det maksimale af to
// typer
egenskabMaksimum {
fnmax(selv, Andet: Selv) -> Selv;
}
// Implementerer "Maximum"-egenskaben for alle typer, der implementerer
// 'PartialOrd'-træk.
implPartialOrd> Maksimum til T {
fnmax(selv, Andet: Selv) -> Selv {
// returnerer `selv` hvis det er større end `andet`; ellers returneres
// `andet.`
hvisselv > andre {
selv
 } andet {
 Andet
 }
 }
}
fnvigtigste() {
lade a = 5;
lade b = 10;
lade største = Maksimum:: max (a, b);
println!("Den største værdi er {}", største);
}

Det Maksimum egenskab har en max metode, der returnerer den største af to værdier af samme type. Enhver type, der implementerer PartialOrd egenskab implementerer Maksimum egenskab.

Det max metoden tager to værdier af Selv type - med henvisning til den type, der implementerer Maksimum egenskab – og sammenligner værdierne.

Det vigtigste funktion sammenligner to variable ved hjælp af max metode og udskriver den største.

Begrænsninger for generiske typer

Begrænsninger ligner egenskabsgrænser, men de giver dig mulighed for at angive yderligere krav til typer, du bruger som typeparametre.

Hvis du vil oprette en generisk funktion, der accepterer typer til strengkonvertering, kan du bruge en begrænsning til at sikre, at typeparameteren implementerer en egenskab.

// ToString er en egenskab med en strengkonverteringsmetode
egenskabToString {
fntil_streng(&selv) -> Snor;
}
// to_string er en generisk funktion, der tager en værdi af enhver type, der
// implementerer ToString-egenskaben
fntil_strengToString>(værdi: T) -> Snor {
 værdi.til_streng()
}

Det til_streng værdi parameter skal implementere ToString egenskab, som sikrer, at du kan konvertere værdier af type T at snore med til_streng metode.

Generiske typer er nyttige til at arbejde med egenskaber

Generiske rusttyper er kraftfulde, og der er områder til forbedring. Et kritisk fokusområde er at forbedre ydeevnen af ​​generisk kode. I øjeblikket kan Rusts typesystem pålægge generisk kode overhead, hvilket bremser ydeevnen.

Generiske typer er gavnlige til at arbejde med egenskaber. Ved at bruge generiske typer kan du oprette egenskabsobjekter, der fungerer med enhver type, der implementerer en egenskab for at gøre dine metoder mere fleksible.