Ruosteen toimintojen ymmärtäminen

Funktiot ovat olennaisia ​​ohjelmointirakenteita, koska ne luovat perustan koodin uudelleenkäytettävyydelle ja helpottavat modulaarista ohjelmointia. Funktiot ovat itsenäisiä koodilohkoja, jotka suorittavat tiettyjä tehtäviä. Ne voivat vastaanottaa syötteitä argumenttien muodossa ja palauttaa arvon.

Rust tarjoaa toimintoja koodin järjestämiseen, kapseloimiseen ja koodin uudelleenkäytettävyyteen.

Ruosteen funktioiden määrittely

Ruostetoiminnot ovat hyvin samanlaisia toimii millä tahansa muulla ohjelmointikielellä, vaikka niissä on pieniä eroja, jotka sinun on ymmärrettävä.

Voit määrittää toiminnot Rust-ohjelmillesi käyttämällä fn avainsana, jota seuraa funktion nimi, valinnaiset argumentit ja valinnainen palautus tietotyyppi.

//-funktio, joka ei ota argumentteja eikä palauta arvoa
fn funktion_nimi() {
// toimintorunko täällä
}

Tässä on yksinkertainen Rust-funktio, joka ei ota vastaan ​​argumentteja tai palauta arvoja.

fn a_function(){
 olkoon x = 3;
println!("{}", x)
}

a_funktio on yksinkertainen Rust-funktio, joka tulostaa muuttujan x.

Rust Function Signatures

Funktioiden allekirjoitukset ovat tapa nimetä funktioita ja kuvata niiden argumentteja ja palautustyyppejä ilman funktion runkoa. Toimintojen allekirjoitukset ovat hyödyllisiä Rust-kirjastojen API: iden dokumentoinnissa.

Tässä on esimerkki Rust-funktion allekirjoituksesta:

fn nimi()
fn tervehdys (nimi: &str)

The nimi funktio on minimaalinen funktion allekirjoitus, kun taas tervehtiä allekirjoitus määrittää, että funktio ottaa yhden argumentin, nimi, tyyppiä merkkijono (&str).

Funktioiden ilmoittaminen argumenteilla ja palautusarvoilla

Ruostefunktiot voivat ottaa vastaan ​​monia argumentteja, eikä rajaa ole erikseen määritelty. Argumentteja sisältävät funktiot ovat yleensä joustavampia, koska ne voivat ottaa arvoja muista funktioista ja koodin osista.

Tässä on tyypillinen Rust-funktion malli, joka ottaa vastaan ​​argumentteja:

fn funktion_nimi (arg: tyyppi, arg2: tyyppi) {
// toimintorunko täällä
}

Toiminnon argumenttityyppi voi olla sisäänrakennettu Rust-tyyppi tai ohjelmasi mukautettu tyyppi.

Tässä on esimerkki yksinkertaisesta funktiosta, joka käyttää argumenteina kaksi kokonaislukua:

fn lisää_numerot (x: i32, y: i32) {
println!("{}", x + y);
}

The add_numbers funktio ottaa kaksi 32-bittistä kokonaislukua ja tulostaa kokonaislukujen summan.

Ruostefunktiot voivat palauttaa useita arvoja; sinun on määritettävä palautustyyppi(t) ja palautettava tyypin arvot funktiosta.

fn funktion_nimi (arg: tyyppi, arg2: tyyppi) -> (tyyppi, tyyppi) {
// toimintorunko täällä
palata arg, arg2
}

Tässä on funktio, joka ottaa argumentiksi merkkijonon ja 32-bittisen kokonaisluvun ja palauttaa argumentit monikkona.

fn merkkijono_ja_kokonaisluku (s: merkkijono, n: i32) -> (merkkijono, i32) {
palata (s, n);
}

The merkkijono_ja_kokonaisluku funktio ottaa merkkijonon ja 32-bittisen kokonaisluvun palauttaen ne monikkona. Voit palauttaa vain yhden arvon ruostefunktiosta.

Voit jättää pois palata avainsana, kun palautat funktion lopullisen lausekkeen, jotta koodi olisi ytimekkäämpi.

fn merkkijono_ja_kokonaisluku (s: merkkijono, n: i32) -> (merkkijono, i32) {
palata (s, n);
}
// funktiot ovat vastaavia
fn str_and_int (s: merkkijono, n: i32) -> (merkkijono, i32) {
 (s, n)
}

Nämä kaksi funktiota käyttäytyvät samalla tavalla, koska ne molemmat ottavat merkkijonon ja kokonaisluvun ja palauttavat nämä argumentit monikkona.

Ruostetoimintojen kutsuminen

Voit kutsua funktiota toisesta kirjoittamalla sen nimen ja arvot, jotka haluat välittää suluissa:

fn lisää_numerot (x: i32, y: i32) -> i32 {
 x + y
}
fn main() {
 anna tulos = add_numbers(3, 5);
println!("Tulos on {}", tulos); // Tulos: Tulos on 8
}

The pää toimintokutsuja add_numbers, ohittamalla sen kaksi kokonaislukua. Se määrittää funktion tuloksen muuttujalle, tulos.

Voit ilmoittaa ruosterakenteiden toiminnot

Voit määrittää funktioita Rust-rakenteissa. Näistä tulee menetelmiä rakenteelle, joka voi käyttää sitä ja muokata sitä.

Rust ei ole puhtaasti oliosuuntautunut, mutta se tarjoaa rakenteita liittyvien tietojen ryhmittelyyn. Voit työskennellä OOP-konseptien toteuttamiseksi Rustissa käyttämällä menetelmiä sisältäviä rakenteita.