A Rust funkcióinak megértése

A függvények alapvető programozási konstrukciók, mivel megalapozzák a kód újrafelhasználhatóságát és megkönnyítik a moduláris programozást. A függvények önálló kódblokkok, amelyek meghatározott feladatokat hajtanak végre. Kaphatnak bemenetet argumentumok formájában, és visszaadhatnak egy értéket.

A Rust funkciókat biztosít a kódszervezéshez, tokozáshoz és a kód újrafelhasználásához.

Funkciók meghatározása Rust-ban

A rozsdafunkciók nagyon hasonlóak bármely más programozási nyelven működik, bár vannak apró különbségek, amelyeket meg kell értened.

A Rust programokhoz tartozó funkciókat a fn kulcsszó után a függvény neve, az opcionális argumentumok és az opcionális visszatérés adattípus.

// függvény, amely nem vesz fel argumentumokat és nem ad vissza értéket
fn függvény_név() {
// funkciótest itt
}

Íme egy egyszerű Rust függvény, amely nem vesz fel semmilyen argumentumot és nem ad vissza semmilyen értéket.

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

a_függvény egy egyszerű Rust függvény, amely kiírja a változót x.

Rust Function Signatures

A függvényaláírások egy mód a függvények elnevezésére, argumentumaik és visszatérési típusaik leírására, függvénytörzs nélkül. A függvényaláírások hasznosak a Rust könyvtárak API-jainak dokumentálásához.

Íme egy példa a Rust függvény aláírására:

fn név()
fn üdvözlés (név: &str)

A név függvény egy minimális függvényaláírás, míg a üdvözöl Az aláírás azt határozza meg, hogy a függvény egyetlen argumentumot vesz fel, név, karakterlánc típusú (&str).

Függvények deklarálása argumentumokkal és visszatérési értékekkel

A rozsdafüggvények sok argumentumot felvehetnek, és a határ nincs kifejezetten meghatározva. Az argumentumokkal rendelkező függvények általában rugalmasabbak, mivel más függvényekből és kódrészekből is átvehetnek értékeket.

Íme a Rust függvény tipikus modellje, amely argumentumokat vesz fel:

fn függvény_neve (arg: típus, arg2: típus) {
// funkciótest itt
}

A függvény argumentumtípusa lehet egy Rust beépített típus vagy egy egyéni típus a programból.

Íme egy példa egy egyszerű függvényre, amely két egész számot vesz fel argumentumként:

fn add_numbers (x: i32, y: i32) {
println!("{}", x + y);
}

A add_numbers A függvény két 32 bites egész számot vesz fel, és kiírja az egész számok összegét.

A rozsdafüggvények több értéket is visszaadhatnak; meg kell adnia a visszatérési típuso(ka)t, és vissza kell adnia a típus értékeit a függvényből.

fn függvény_neve (arg: típus, arg2: típus) -> (típus, típus) {
// funkciótest itt
Visszatérés arg, arg2
}

Itt van egy függvény, amely egy karakterláncot és egy 32 bites egész számot vesz fel argumentumként, és az argumentumokat sorként adja vissza.

fn string_and_integer (s: String, n: i32) -> (String, i32) {
Visszatérés (s, n);
}

A karakterlánc_és egész szám függvény egy karakterláncot és egy 32 bites egész számot vesz fel, és ezeket sorként adja vissza. Rust függvényből csak egyetlen értéket adhat vissza.

Kihagyhatja a Visszatérés kulcsszót, amikor a függvény végső kifejezését adja vissza, hogy a kód tömörebb legyen.

fn string_and_integer (s: String, n: i32) -> (String, i32) {
Visszatérés (s, n);
}
// a függvények egyenértékűek
fn str_and_int (s: String, n: i32) -> (String, i32) {
 (s, n)
}

Ez a két függvény viselkedése azonos, mivel mindkettő karakterláncot és egész számot vesz fel, és ezeket az argumentumokat sorként adja vissza.

Rust Functions hívása

Meghívhat egy függvényt a másikból, ha beírja a nevét, majd zárójelben az átadni kívánt értékeket:

fn add_numbers (x: i32, y: i32) -> i32 {
 x + y
}
fn main() {
 legyen eredmény = add_numbers(3, 5);
println!("Az eredmény: {}", eredmény); // Kimenet: Az eredmény: 8
}

A fő- függvényhívások add_numbers, átadva két egész számot. A függvény eredményét egy változóhoz rendeli, eredmény.

Bejelentheti a rozsdaszerkezetek funkcióit

Függvényeket deklarálhat a Rust struktúrákon belül. Ezek olyan metódusokká válnak a struktúra számára, amelyek hozzáférhetnek és módosíthatják azt.

A Rust nem tisztán objektum-orientált, de struktúrákat biztosít a kapcsolódó adatok csoportosításához. Dolgozhat az OOP-koncepciók Rust-ban való megvalósításán metódusos struktúrák használatával.