Pochopení funkcí v Rustu

Funkce jsou základní programovací konstrukty, protože pokládají základ pro opětovné použití kódu a usnadňují modulární programování. Funkce jsou samostatné bloky kódu, které provádějí specifické úkoly. Mohou přijímat vstup ve formě argumentů a vracet hodnotu.

Rust poskytuje funkce pro organizaci kódu, zapouzdření a opětovné použití kódu.

Definování funkcí v Rust

Funkce rzi jsou podobné funguje v jakémkoli jiném programovacím jazyce, i když existují malé rozdíly, které musíte pochopit.

Funkce pro své programy Rust definujete pomocí fn klíčové slovo následované názvem funkce, volitelnými argumenty a volitelným návratem datový typ.

// funkce, která nebere argumenty ani nevrací hodnotu
fn název_funkce() {
// tělo funkce zde
}

Zde je jednoduchá funkce Rust, která nepřijímá žádné argumenty ani nevrací žádné hodnoty.

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

a_funkce je jednoduchá funkce Rust, která vypíše proměnnou X.

Podpisy funkce Rust

Signatury funkcí představují způsob pojmenování funkcí a popisu jejich argumentů a návratových typů, aniž by obsahovaly tělo funkce. Podpisy funkcí jsou užitečné pro dokumentaci API knihoven Rust.

Zde je příklad podpisu funkce Rust:

fn name()
fn pozdrav (jméno: &str)

The název funkce je minimální podpis funkce, zatímco pozdravit podpis určuje, že funkce přijímá jeden argument, název, typu řetězec (&str).

Deklarace funkcí s argumenty a návratovými hodnotami

Funkce Rust mohou obsahovat mnoho argumentů a limit není explicitně definován. Funkce s argumenty jsou obecně flexibilnější, protože mohou přebírat hodnoty z jiných funkcí a částí kódu.

Zde je typický model funkce Rust, který přijímá argumenty:

fn název_funkce (arg: typ, argument2: typ) {
// tělo funkce zde
}

Typ argumentu funkce může být vestavěný typ Rust nebo vlastní typ z vašeho programu.

Zde je příklad jednoduché funkce, která má jako argumenty dvě celá čísla:

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

The přidat_čísla funkce vezme dvě 32bitová celá čísla a vypíše součet celých čísel.

Funkce Rust mohou vracet více hodnot; budete muset zadat návratový typ (y) a vrátit hodnoty typu z funkce.

fn název_funkce (arg: typ, argument2: typ) -> (typ, typ) {
// tělo funkce zde
vrátit se arg, arg2
}

Zde je funkce, která jako argument přijímá řetězec a 32bitové celé číslo a vrací argumenty jako n-tici.

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

The string_and_integer funkce přijímá řetězec a 32bitové celé číslo a vrací je jako n-tici. Z funkce Rust můžete vrátit pouze jednu hodnotu.

Můžete vynechat vrátit se klíčové slovo při vrácení konečného výrazu z funkce, aby byl kód stručnější.

fn string_and_integer (s: String, n: i32) -> (String, i32) {
vrátit se (s, n);
}
// funkce jsou ekvivalentní
fn str_and_int (s: řetězec, n: i32) -> (řetězec, i32) {
 (s, n)
}

Tyto dvě funkce se chovají stejně, protože obě berou řetězec a celé číslo a vracejí tyto argumenty jako n-tici.

Volání funkcí Rust

Jednu funkci můžete volat z druhé tak, že napíšete její název následovaný hodnotami, které jí chcete předat, do závorek:

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

The hlavní volání funkcí přidat_čísla, předáte mu dvě celá čísla. Přiřadí výsledek funkce proměnné, výsledek.

Můžete deklarovat funkce pro rezavé konstrukce

Funkce můžete deklarovat ve strukturách Rust. Ty se stanou metodami pro strukturu, která k ní může přistupovat a upravovat ji.

Rust není čistě objektově orientovaný, ale poskytuje struktury pro seskupování souvisejících dat. Můžete pracovat na implementaci konceptů OOP v Rustu pomocí struktur s metodami.