Понимание функций в Rust

Функции являются важными конструкциями программирования, поскольку они закладывают основу для повторного использования кода и упрощают модульное программирование. Функции — это автономные блоки кода, выполняющие определенные задачи. Они могут получать входные данные в виде аргументов и возвращать значение.

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

Определение функций в Rust

Функции Rust очень похожи функции на любом другом языке программирования, хотя есть небольшие различия, которые вам нужно понять.

Вы будете определять функции для своих программ на Rust с помощью фн ключевое слово, за которым следует имя функции, необязательные аргументы и необязательный возврат тип данных.

// функция, которая не принимает аргументы и не возвращает значение
fn имя_функции () {
// тело функции здесь
}

Вот простая функция Rust, которая не принимает никаких аргументов и не возвращает никаких значений.

fn a_function(){
 пусть х = 3;
печать!("{}", Икс)
}

функция это простая функция Rust, которая печатает переменную Икс.

Сигнатуры функций Rust

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

Вот пример сигнатуры функции Rust:

фн имя ()
fn приветствовать (имя: &str)

имя function — это минимальная сигнатура функции, а приветствовать подпись указывает, что функция принимает один аргумент, имя, типа строка (&стр).

Объявление функций с аргументами и возвращаемыми значениями

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

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

fn имя_функции (аргумент: тип, аргумент2: тип) {
// тело функции здесь
}

Тип аргумента функции может быть встроенным типом Rust или пользовательским типом из вашей программы.

Вот пример простой функции, которая принимает два целых числа в качестве аргументов:

fn add_numbers (x: i32, y: i32) {
печать!("{}", х + у);
}

add_numbers Функция принимает два 32-битных целых числа и выводит их сумму.

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

fn имя_функции (аргумент: тип, аргумент2: тип) -> (тип, тип) {
// тело функции здесь
возвращаться аргумент, аргумент2
}

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

fn string_and_integer (s: строка, n: i32) -> (строка, i32) {
возвращаться (с, н);
}

string_and_integer Функция принимает строку и 32-битное целое число, возвращая их в виде кортежа. Вы можете вернуть только одно значение из функции Rust.

Вы можете опустить возвращаться ключевое слово при возврате конечного выражения из функции, чтобы сделать код более кратким.

fn string_and_integer (s: строка, n: i32) -> (строка, i32) {
возвращаться (с, н);
}
// функции эквивалентны
fn str_and_int (s: строка, n: i32) -> (строка, i32) {
 (с, н)
}

Эти две функции имеют одинаковое поведение, поскольку обе они принимают строку и целое число и возвращают эти аргументы в виде кортежа.

Вызов функций Rust

Вы можете вызвать одну функцию из другой, написав ее имя, а затем значения, которые вы хотите передать ей в круглых скобках:

fn add_numbers (x: i32, y: i32) -> i32 {
 х + у
}
главная функция () {
 пусть результат = add_numbers(3, 5);
печать!("Результат {}", результат); // Вывод: результат равен 8
}

основной вызовы функций add_numbers, передав ему два целых числа. Он присваивает результат функции переменной, результат.

Вы можете объявлять функции для структур Rust

Вы можете объявлять функции внутри структур Rust. Они становятся методами структуры, которые могут получать к ней доступ и изменять ее.

Rust не является чисто объектно-ориентированным, но предоставляет структуры для группировки связанных данных. Вы можете работать над реализацией концепций ООП в Rust, используя структуры с методами.