Pochopenie funkcií v Rust

Funkcie sú základnými programovacími konštruktmi, pretože kladú základ pre znovupoužiteľnosť kódu a uľahčujú modulárne programovanie. Funkcie sú samostatné bloky kódu, ktoré vykonávajú špecifické úlohy. Môžu prijímať vstup vo forme argumentov a vrátiť hodnotu.

Rust poskytuje funkcie pre organizáciu kódu, zapuzdrenie a opätovné použitie kódu.

Definovanie funkcií v Rust

Funkcie hrdze sú podobné funguje v akomkoľvek inom programovacom jazyku, aj keď existujú malé rozdiely, ktoré musíte pochopiť.

Funkcie pre svoje programy Rust definujete pomocou fn kľúčové slovo, za ktorým nasleduje názov funkcie, voliteľné argumenty a voliteľný návrat Dátový typ.

// funkcia, ktorá neprijíma argumenty ani nevracia hodnotu
fn názov_funkcie() {
// telo funkcie tu
}

Tu je jednoduchá funkcia Rust, ktorá neprijíma žiadne argumenty ani nevracia žiadne hodnoty.

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

a_funkcia je jednoduchá funkcia Rust, ktorá vypíše premennú X.

Podpisy funkcie hrdze

Podpisy funkcií predstavujú spôsob pomenovávania funkcií a opisu ich argumentov a návratových typov bez zahrnutia tela funkcie. Podpisy funkcií sú užitočné na dokumentovanie API knižníc Rust.

Tu je príklad podpisu funkcie Rust:

fn name()
fn pozdrav (meno: &str)

The názov funkcia je podpis minimálnej funkcie, zatiaľ čo pozdraviť podpis určuje, že funkcia má jeden argument, názov, typu string (&str).

Deklarovanie funkcií s argumentmi a návratovými hodnotami

Funkcie hrdze môžu mať veľa argumentov a limit nie je explicitne definovaný. Funkcie s argumentmi sú vo všeobecnosti flexibilnejšie, pretože môžu preberať hodnoty z iných funkcií a častí kódu.

Tu je typický model funkcie Rust, ktorý využíva argumenty:

fn názov_funkcie (arg: typu, argument2: typu) {
// telo funkcie tu
}

Typ argumentu funkcie môže byť vstavaný typ Rust alebo vlastný typ z vášho programu.

Tu je príklad jednoduchej funkcie, ktorá berie ako argumenty dve celé čísla:

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

The pridať_čísla funkcia vezme dve 32-bitové celé čísla a vypíše súčet celých čísel.

Funkcie hrdze môžu vrátiť viacero hodnôt; budete musieť zadať návratový typ (y) a vrátiť hodnoty typu z funkcie.

fn názov_funkcie (arg: typu, argument2: typu) -> (typu, typu) {
// telo funkcie tu
vrátiť arg, arg2
}

Tu je funkcia, ktorá berie ako argument reťazec a 32-bitové celé číslo a vracia argumenty ako n-ticu.

fn string_and_integer (s: String, n: i32) -> (String, i32) {
vrátiť (s, n);
}

The string_and_integer funkcia berie reťazec a 32-bitové celé číslo a vracia ich ako n-ticu. Z funkcie Rust môžete vrátiť iba jednu hodnotu.

Môžete vynechať vrátiť kľúčové slovo pri vrátení konečného výrazu z funkcie, aby bol kód stručnejší.

fn string_and_integer (s: String, n: i32) -> (String, i32) {
vrátiť (s, n);
}
// funkcie sú ekvivalentné
fn str_and_int (s: reťazec, n: i32) -> (reťazec, i32) {
 (s, n)
}

Tieto dve funkcie majú rovnaké správanie, pretože obe berú reťazec a celé číslo a vracajú tieto argumenty ako n-ticu.

Volanie funkcií Rust

Jednu funkciu môžete volať z druhej tak, že napíšete jej názov a do zátvoriek hodnoty, ktoré jej chcete odovzdať:

fn add_numbers (x: i32, y: i32) -> i32 {
 x + y
}
fn main() {
 nech výsledok = add_numbers(3, 5);
println!("Výsledok je {}", výsledok); // Výstup: Výsledok je 8
}

The Hlavná volania funkcií pridať_čísla, pričom jej odovzdajú dve celé čísla. Výsledok funkcie priradí premennej, výsledok.

Môžete deklarovať funkcie pre hrdzavé konštrukcie

Funkcie môžete deklarovať v rámci štruktúr Rust. Tieto sa stávajú metódami pre štruktúru, ktorá k nej môže pristupovať a upravovať ju.

Rust nie je čisto objektovo orientovaný, ale poskytuje štruktúry na zoskupovanie súvisiacich údajov. Môžete pracovať na implementácii konceptov OOP v Ruste pomocou štruktúr s metódami.