Înțelegerea funcțiilor în Rust

Funcțiile sunt constructe de programare esențiale, deoarece pun bazele reutilizabilității codului și facilitează programarea modulară. Funcțiile sunt blocuri de cod autonome care îndeplinesc sarcini specifice. Ei pot primi intrare, sub formă de argumente, și pot returna o valoare.

Rust oferă funcții pentru organizarea codului, încapsularea și reutilizarea codului.

Definirea funcțiilor în Rust

Funcțiile de rugină sunt foarte asemănătoare funcţionează în orice alt limbaj de programare, deși există mici diferențe pe care va trebui să le înțelegeți.

Veți defini funcțiile pentru programele dvs. Rust cu ajutorul fn cuvânt cheie urmat de numele funcției, argumente opționale și o returnare opțională tip de date.

// funcție care nici nu preia argumente și nici nu returnează o valoare
fn nume_funcție() {
// corpul de funcții aici
}

Iată o funcție Rust simplă care nu preia niciun argument și nu returnează nicio valoare.

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

o functie este o funcție Rust simplă care imprimă variabila X.

Semnăturile funcției de rugină

Semnăturile funcțiilor sunt o modalitate de a numi funcții și de a descrie argumentele și tipurile de returnare ale acestora, fără a include un corp de funcție. Semnăturile funcțiilor sunt utile pentru documentarea API-urilor bibliotecilor Rust.

Iată un exemplu de semnătură a funcției Rust:

fn nume()
fn salut (nume: &str)

The Nume funcția este o semnătură minimă a funcției, în timp ce salut semnătura specifică faptul că funcția ia un singur argument, Nume, de tip șir (&str).

Declararea funcțiilor cu argumente și a valorilor returnate

Funcțiile Rust pot prelua multe argumente, iar limita nu este definită în mod explicit. Funcțiile cu argumente sunt în general mai flexibile, deoarece pot prelua valori din alte funcții și părți de cod.

Iată modelul tipic al unei funcții Rust care preia argumente:

fn nume_funcție (arg: tip, arg2: tip) {
// corpul de funcții aici
}

Tipul de argument al funcției poate fi un tip încorporat Rust sau un tip personalizat din programul dvs.

Iată un exemplu de funcție simplă care ia ca argumente două numere întregi:

fn numere_adăugați (x: i32, y: i32) {
println!("{}", x + y);
}

The add_numbers funcția preia două numere întregi de 32 de biți și tipărește suma numerelor întregi.

Funcțiile Rust pot returna mai multe valori; va trebui să specificați tipul (tipurile) de returnare și să returnați valorile tipului din funcție.

fn nume_funcție (arg: tip, arg2: tip) -> (tip, tip) {
// corpul de funcții aici
întoarcere arg, arg2
}

Iată o funcție care preia un șir și un întreg de 32 de biți ca argument și returnează argumentele ca tuplu.

fn șir_și_întreg (s: șir, n: i32) -> (șir, i32) {
întoarcere (s, n);
}

The șir_și_întreg funcția preia un șir și un întreg de 32 de biți, returnându-le ca un tuplu. Puteți returna doar o singură valoare dintr-o funcție Rust.

Puteți lăsa deoparte întoarcere cuvânt cheie atunci când returnați expresia finală dintr-o funcție, pentru a face codul mai concis.

fn șir_și_întreg (s: șir, n: i32) -> (șir, i32) {
întoarcere (s, n);
}
// funcțiile sunt echivalente
fn str_and_int (s: String, n: i32) -> (String, i32) {
 (s, n)
}

Aceste două funcții au același comportament, deoarece ambele preiau un șir și un întreg și returnează acele argumente ca un tuplu.

Apelarea funcțiilor Rust

Puteți apela o funcție de la alta scriindu-i numele urmat de valorile pe care doriți să le transmiteți în paranteze:

fn numere_adăugați (x: i32, y: i32) -> i32 {
 x + y
}
fn principal() {
 lasă rezultat = add_numbers(3, 5);
println!("Rezultatul este {}", rezultat); // Ieșire: rezultatul este 8
}

The principal apeluri de funcții add_numbers, trecându-i două numere întregi. El atribuie rezultatul funcției unei variabile, rezultat.

Puteți declara funcții pentru structurile de rugină

Puteți declara funcții în structurile Rust. Acestea devin metode pentru structura care o poate accesa și modifica.

Rust nu este orientat doar pe obiecte, dar oferă structuri pentru gruparea datelor legate. Puteți lucra la implementarea conceptelor OOP în Rust folosind structuri cu metode.