Разбиране на функциите в Rust

Функциите са основни програмни конструкции, тъй като те полагат основата за повторно използване на кода и улесняват модулното програмиране. Функциите са самостоятелни блокове код, които изпълняват специфични задачи. Те могат да получават входни данни под формата на аргументи и да връщат стойност.

Rust предоставя функции за организация на кода, капсулиране и повторно използване на кода.

Дефиниране на функции в Rust

Функциите на Rust са много подобни функции на всеки друг език за програмиране, въпреки че има малки разлики, които ще трябва да разберете.

Ще дефинирате функции за вашите програми Rust с fn ключова дума, последвана от името на функцията, аргументи по избор и връщане по избор тип данни.

// функция, която нито приема аргументи, нито връща стойност
fn име_на_функция() {
// тяло на функция тук
}

Ето една проста функция на Rust, която не приема никакви аргументи и не връща никакви стойности.

fn a_function(){
 нека x = 3;
println!("{}", х)
}

a_функция е проста функция на Rust, която отпечатва променливата х.

Сигнатури на Rust Function

Сигнатурите на функциите са начин за наименуване на функции и описване на техните аргументи и връщани типове, без да се включва тяло на функция. Функционалните подписи са полезни за документиране на API на библиотеки на Rust.

Ето примерен подпис на функция Rust:

име на fn()
fn поздрави (име: &str)

The име е минимален функционален подпис, докато поздравявам подписът указва, че функцията приема един аргумент, име, от тип низ (&str).

Деклариране на функции с аргументи и връщани стойности

Функциите на Rust могат да приемат много аргументи и ограничението не е изрично дефинирано. Функциите с аргументи обикновено са по-гъвкави, тъй като могат да приемат стойности от други функции и части от кода.

Ето типичния модел на функция Rust, която приема аргументи:

fn име_на_функция (арг: Тип, arg2: Тип) {
// тяло на функция тук
}

Типът аргумент на функцията може да бъде вграден тип в Rust или потребителски тип от вашата програма.

Ето пример за проста функция, която приема две цели числа като аргументи:

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

The добавяне на числа функцията приема две 32-битови цели числа и отпечатва сумата от целите числа.

Функциите на Rust могат да връщат множество стойности; ще трябва да посочите връщания тип (ове) и да върнете стойностите на типа от функцията.

fn име_на_функция (арг: Тип, arg2: Тип) -> (Тип, Тип) {
// тяло на функция тук
връщане arg, arg2
}

Ето една функция, която приема низ и 32-битово цяло число като аргумент и връща аргументите като кортеж.

fn string_and_integer (s: String, n: i32) -> (String, i32) {
връщане (s, n);
}

The низ_и_цяло число функцията приема низ и 32-битово цяло число, връщайки ги като кортеж. Можете да върнете само една стойност от Rust функция.

Можете да пропуснете връщане ключова дума, когато връща крайния израз от функция, за да направи кода по-сбит.

fn string_and_integer (s: String, n: i32) -> (String, i32) {
връщане (s, n);
}
// функциите са еквивалентни
fn str_and_int (s: String, n: i32) -> (String, i32) {
 (s, n)
}

Тези две функции имат едно и също поведение, тъй като и двете приемат низ и цяло число и връщат тези аргументи като кортеж.

Извикване на Rust функции

Можете да извикате една функция от друга, като напишете нейното име, последвано от стойности, които искате да й предадете в скоби:

fn add_numbers (x: i32, y: i32) -> i32 {
 x + y
}
fn main() {
 нека резултат = add_numbers(3, 5);
println!(„Резултатът е {}“, резултат); // Изход: Резултатът е 8
}

The основен извиквания на функции добавяне на числа, предавайки му две цели числа. Той присвоява резултата от функцията на променлива, резултат.

Можете да декларирате функции за Rust Structs

Можете да декларирате функции в структурите на Rust. Те стават методи за структурата, която има достъп до нея и я променя.

Rust не е изцяло обектно-ориентиран, но предоставя структури за групиране на свързани данни. Можете да работите за прилагане на OOP концепции в Rust, като използвате структури с методи.