Geneerisen koodin kirjoittaminen Rustilla
Opitte kirjoittamaan funktioita ja tietorakenteita, jotka toimivat useilla tyypeillä ja parantavat koodin uudelleenkäytettävyyttä tinkimättä tyyppiturvallisuudesta.
Geneerisen koodin kirjoittaminen Rustilla on ilmainen Rust-ohjelmoinnin perusteet-oppitunti CoddyKitissä. Tämä on oppitunti 1/3. Voit lukea tästä oppimispolusta kokonaan mitkä tahansa 3 oppituntia ilmaiseksi — sen jälkeen CoddyKit PRO avaa kaikki oppitunnit sekä käytännön harjoittelun sisäänrakennetulla koodieditorilla ja ympäri vuorokauden toimivalla tekoälytuutorilla. Oppitunti kuuluu Rust-ohjelmoinnin perusteet-oppimispolkuun, ja edistymisesi synkronoituu verkon ja CoddyKit-sovelluksen välillä. Rust-ohjelmoinnin perusteet-kurssilla on yhteensä 3 oppituntia.
Miksi kirjoittaa geneeristä koodia?
Kuvitelkaa, että tarvitsette funktion, joka etsii luettelon suurimman alkion. Entä jos tarvitsette sen luvuille, sitten merkeille ja lopuksi mukautetuille olioille?
Ilman geneerisyyttä kirjoittaisitte erillisen funktion jokaiselle tyypille, mikä johtaisi runsaaseen toistuvaan koodiin. Tässä geneerisyys tulee avuksi!
Geneerisyyden esittely
Geneerisyyden avulla voitte kirjoittaa useiden tyyppien kanssa toimivaa koodia toistamatta itseänne. Se on tapa kirjoittaa joustavia ja uudelleenkäytettäviä funktioita tai tietorakenteita.
Ajatelkaa sitä suunnitelmana, jota voidaan mukauttaa eri materiaaleille.
Ensimmäinen geneerinen funktionne
Jotta funktiosta tulee geneerinen, ilmoittakaa tyyppiparametrit kulmasulkeissa <> funktion nimen jälkeen. Yleinen tyyppiparametrin nimi on T (sanasta Type).
Tämä print_anything-funktio voi nyt tulostaa minkä tahansa tyypin!
fn print_anything<T>(item: T) {
println!("The item is: {}", item);
}
pub fn main() {
print_anything(5);
print_anything("hello");
print_anything(true);
}Tyyppiparametrit selitettyinä
<T> kohdassa fn print_anything<T>(item: T) tarkoittaa, että T on tyypin paikanhaltija. Kun kutsutte funktiota arvolla i32, T:stä tulee i32.
- Tyyppiparametrit: Geneeriset tyypit nimetään yleensä isoilla kirjaimilla, kuten
T,UjaV. - Joustavuus: Kääntäjä selvittää konkreettisen tyypin käännöksen aikana.
Toiminnallisuuden lisääminen: trait-rajoitteet
Joskus geneerinen funktionne edellyttää, että sen tyyppiparametrilla T on tiettyjä toimintoja. Jos esimerkiksi haluatte vertailla kahta T-arvoa, T-arvojen on oltava vertailukelpoisia.
Lisäämme trait-rajoitteet näiden vaatimusten määrittämiseksi. Tässä T: PartialOrd + Copy tarkoittaa, että T:n on toteutettava traitit PartialOrd (osittainen järjestys vertailua varten) ja Copy.
fn largest<T: PartialOrd + Copy>(list: &[T]) -> T {
let mut largest = list[0];
for &item in list.iter() {
if item > largest {
largest = item;
}
}
largest
}
pub fn main() {
let number_list = vec![34, 50, 25, 100, 65];
println!("Largest number: {}", largest(&number_list));
let char_list = vec!['y', 'm', 'a', 'q'];
println!("Largest char: {}", largest(&char_list));
}Useiden trait-rajoitteiden syntaksi
Voitte vaatia geneeriseltä tyypiltä useita trait-toteutuksia käyttämällä +-syntaksia, kuten T: TraitA + TraitB.
Monimutkaisissa rajoitteissa voitte käyttää funktion allekirjoituksen jälkeen myös where-ehtoa, joka voi tehdä allekirjoituksesta selkeämmän:
fn some_function<T, U>(t: T, u: U) -> i32 where T: Display + Clone, U: Clone + Debug { /* ... */ }
Geneeriset struct-rakenteet
Funktioiden tavoin voitte määritellä struct-rakenteita geneerisiksi yhden tai useamman tyyppiparametrin suhteen. Näin tietorakenteenne voivat sisältää minkä tahansa määritetyn tyyppistä tietoa.
Point<T>-struct-rakenne voi sisältää minkä tahansa tyypin T koordinaatteja (esimerkiksi i32 tai f64).
struct Point<T> {
x: T,
y: T,
}
pub fn main() {
let integer_point = Point {
x: 5,
y: 10
};
let float_point = Point {
x: 1.0,
y: 4.0
};
println!("Int Point: ({}, {})",
integer_point.x, integer_point.y);
println!("Float Point: ({}, {})",
float_point.x, float_point.y);
}Metodien toteuttaminen geneerisille struct-rakenteille
Kun toteutatte metodeja geneeriselle struct-rakenteelle, geneerinen tyyppiparametri tai -parametrit on määritettävä impl-sanan jälkeen.
Voitte lisätä metodeille myös trait-rajoitteita, jos metodi edellyttää geneerisiltä tyypeiltään tiettyä toimintaa.
struct Point<T> {
x: T,
y: T,
}
impl<T> Point<T> {
fn x(&self) -> &T {
&self.x
}
}
pub fn main() {
let p = Point {
x: 5,
y: 10
};
println!("p.x = {}", p.x());
}Geneerisyys ja suorituskyky
Yksi Rustin vahvuuksista on, että geneerisyys on nollakustannuksinen abstraktio. Tämä tarkoittaa, ettei geneerisyys aiheuta suorituskykyhaittaa ohjelman suorituksen aikana.
Rust saavuttaa tämän monomorfisaation avulla: käännöksen aikana kääntäjä luo geneerisestä koodistanne erikoistuneet versiot jokaista konkreettista käytettyä tyyppiä varten. Siksi largest<i32> ja largest<char> muuttuvat kahdeksi erilliseksi, optimoiduksi funktioksi.
Testatkaa tietonne
Mitkä seuraavista Rustin geneerisyyttä koskevista väitteistä ovat TOSIA?
Kertaus: geneerisyyden voima
Tässä oppitunnissa olette oppineet Rustin geneerisen koodin kirjoittamisen perusteet:
- Mitä ne ovat: tapa kirjoittaa joustavaa ja uudelleenkäytettävää koodia.
- Geneeriset funktiot: tyyppiparametrien käyttäminen muodossa
<T>. - Trait-rajoitteet: vaadittujen toimintojen määrittäminen muodossa
T: Trait. - Geneeriset struct-rakenteet: tietorakenteiden luominen geneerisiä tyyppejä varten.
- Nollakustannus: Rust kääntää geneerisen koodin tyyppikohtaiseksi koodiksi, joten suorituksen aikana ei aiheudu suorituskykyhaittaa.
Geneerisyys on idiomaattisen Rustin kulmakivi, joka mahdollistaa tehokkaat ja tyyppiturvalliset abstraktiot!
Opi Rust tekoälytuutorin avulla — ilmaiseksi
Kirjoita ja suorita oikeaa koodia selaimessa, saa välitöntä apua tekoälytuutorilta ympäri vuorokauden ja jatka siitä, mihin jäit, verkossa tai sovelluksessa.
- Kurssit
- 39
- Oppitunnit
- 144
Usein kysytyt kysymykset
Onko oppitunti ”Geneerisen koodin kirjoittaminen Rustilla” ilmainen?
Kyllä — voit lukea täällä verkossa kokonaan ilmaiseksi mitkä tahansa Rust-ohjelmoinnin perusteet-oppimispolun 3 oppituntia, myös oppitunnin “Geneerisen koodin kirjoittaminen Rustilla”. Sen jälkeen CoddyKit PRO avaa kaikki oppitunnit sekä interaktiiviset harjoitukset sisäänrakennetulla koodieditorilla ja ympäri vuorokauden toimivalla tekoälytuutorilla. Rust-ohjelmoinnin perusteet-kurssilla on yhteensä 3 oppituntia.
Mitä opin oppitunnilla ”Geneerisen koodin kirjoittaminen Rustilla”?
Opitte kirjoittamaan funktioita ja tietorakenteita, jotka toimivat useilla tyypeillä ja parantavat koodin uudelleenkäytettävyyttä tinkimättä tyyppiturvallisuudesta. Harjoittelet Rust-ohjelmoinnin perusteet-aihetta koodilla, jonka suoritat suoraan selaimessa. Ympäri vuorokauden käytettävissä oleva tekoälytuutori vastaa kysymyksiisi oppitunnin aikana.
Tarvitsenko kokemusta aloittaakseni Rust-ohjelmoinnin perusteet-opiskelun?
Aiempi kokemus ei ole tarpeen. CoddyKitin Rust-ohjelmoinnin perusteet-oppimispolku sopii vasta-alkajista edistyneisiin, joten voit aloittaa tästä tai alusta ja edetä omaan tahtiisi. Tämä on oppitunti 1/3.
Kuinka kauan ”Geneerisen koodin kirjoittaminen Rustilla”-oppitunnin suorittaminen kestää?
Useimmat CoddyKitin oppitunnit kestävät noin 5–10 minuuttia. Jokainen oppitunti on lyhyt ja interaktiivinen, joten edistyt tasaisesti ja voit jatkaa siitä, mihin jäit – sekä verkossa että sovelluksessa.
Voinko kirjoittaa ja suorittaa koodia tällä Rust-ohjelmoinnin perusteet-oppitunnilla?
Kyllä. Jokainen Rust-ohjelmoinnin perusteet-oppitunti sisältää sisäänrakennetun koodieditorin, joten voit kirjoittaa ja suorittaa oikeaa koodia suoraan selaimessa ja saada välitöntä palautetta tekoälyltä – paikallista asennusta ei tarvita.
Kaikki tämän kurssin oppitunnit
- Geneerisen koodin kirjoittaminen Rustilla
- Trait-ominaisuuksien määrittäminen ja toteuttaminen
- Trait-ominaisuuksien edistynyt käyttö: associated types