Горячие клавиши

Нажмите ← или → для перехода между главами

Нажмите S или / для поиска по книге

Нажмите ?, чтобы показать эту справку

Нажмите Esc, чтобы скрыть эту справку

Функции

Функции повсеместно встречаются в коде на Rust. Уже была показана одна из наиболее важных функций в языке: функция main, которая является точкой входа многих программ. Также было показано ключевое слово fn, которое позволяет объявлять новые функции.

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

Имя файла: src/main.rs

fn main() {
    println!("Hello, world!");

    another_function();
}

fn another_function() {
    println!("Another function.");
}

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

Любую определённую функцию можно вызвать, введя её имя, за которым следует набор круглых скобок. Поскольку another_function определена в программе, её можно вызвать изнутри функции main. Заметим, что another_function определена после функции main в исходном коде; её можно было определить и до. Rust не важно, где определяются функции, важно лишь, что они определены где-то в области видимости, доступной вызывающему коду.

Начнём новый бинарный проект с именем functions, чтобы изучить функции подробнее. Поместите пример с another_function в src/main.rs и запустите его. Должен появиться следующий вывод:

$ cargo run
   Compiling functions v0.1.0 (file:///projects/functions)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.28s
     Running `target/debug/functions`
Hello, world!
Another function.

Строки выполняются в том порядке, в котором они появляются в функции main. Сначала выводится сообщение «Hello, world!», а затем вызывается another_function и выводится её сообщение.

Параметры

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

В этой версии another_function добавлен параметр:

Имя файла: src/main.rs

fn main() {
    another_function(5);
}

fn another_function(x: i32) {
    println!("The value of x is: {x}");
}

Попробуйте запустить эту программу; должен получиться следующий вывод:

$ cargo run
   Compiling functions v0.1.0 (file:///projects/functions)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 1.21s
     Running `target/debug/functions`
The value of x is: 5

Объявление another_function имеет один параметр с именем x. Тип x указан как i32. Когда в another_function передаётся 5, макрос println! помещает 5 туда, где в строке формата находилась пара фигурных скобок с x.

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

При определении нескольких параметров объявления параметров разделяются запятыми, вот так:

Имя файла: src/main.rs

fn main() {
    print_labeled_measurement(5, 'h');
}

fn print_labeled_measurement(value: i32, unit_label: char) {
    println!("The measurement is: {value}{unit_label}");
}

Этот пример создаёт функцию с именем print_labeled_measurement с двумя параметрами. Первый параметр называется value и имеет тип i32. Второй называется unit_label и имеет тип char. Затем функция выводит текст, содержащий как value, так и unit_label.

Попробуем запустить этот код. Замените программу, находящуюся сейчас в файле src/main.rs проекта functions, на предыдущий пример и запустите её с помощью cargo run:

$ cargo run
   Compiling functions v0.1.0 (file:///projects/functions)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.31s
     Running `target/debug/functions`
The measurement is: 5h

Поскольку функция была вызвана со значением 5 для value и 'h' в качестве значения для unit_label, вывод программы содержит эти значения.

Операторы и выражения

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

  • Операторы — это инструкции, которые выполняют некоторое действие и не возвращают значение.
  • Выражения вычисляются в результирующее значение.

Рассмотрим несколько примеров.

Операторы и выражения уже фактически использовались. Создание переменной и присваивание ей значения с помощью ключевого слова let — это оператор. В листинге 3-1 let y = 6; — это оператор.

Имя файла: src/main.rs
fn main() {
    let y = 6;
}
Листинг 3-1: Объявление функции main, содержащее один оператор

Определения функций также являются операторами; весь предыдущий пример — это оператор сам по себе. (Как вскоре будет показано, вызов функции не является оператором.)

Операторы не возвращают значений. Поэтому нельзя присвоить оператор let другой переменной, как пытается сделать следующий код; будет получена ошибка:

Имя файла: src/main.rs

fn main() {
    let x = (let y = 6);
}

При запуске этой программы ошибка будет выглядеть так:

$ cargo run
   Compiling functions v0.1.0 (file:///projects/functions)
error: expected expression, found `let` statement
 --> src/main.rs:2:14
  |
2 |     let x = (let y = 6);
  |              ^^^
  |
  = note: only supported directly in conditions of `if` and `while` expressions

warning: unnecessary parentheses around assigned value
 --> src/main.rs:2:13
  |
2 |     let x = (let y = 6);
  |             ^         ^
  |
  = note: `#[warn(unused_parens)]` (part of `#[warn(unused)]`) on by default
help: remove these parentheses
  |
2 -     let x = (let y = 6);
2 +     let x = let y = 6 ;
  |

warning: `functions` (bin "functions") generated 1 warning
error: could not compile `functions` (bin "functions") due to 1 previous error; 1 warning emitted

Оператор let y = 6 не возвращает значение, поэтому нечего привязать к x. Это отличается от того, что происходит в других языках, таких как C и Ruby, где присваивание возвращает значение присваивания. В этих языках можно написать x = y = 6, и обе переменные x и y будут иметь значение 6; в Rust это не так.

Выражения вычисляются в значение и составляют большую часть остального кода, который будет написан на Rust. Рассмотрим математическую операцию, такую как 5 + 6, которая является выражением, вычисляющимся в значение 11. Выражения могут быть частью операторов: в листинге 3-1 6 в операторе let y = 6; — это выражение, вычисляющееся в значение 6. Вызов функции — это выражение. Вызов макроса — это выражение. Блок новой области видимости, созданный с помощью фигурных скобок, — это выражение, например:

Имя файла: src/main.rs

fn main() {
    let y = {
        let x = 3;
        x + 1
    };

    println!("The value of y is: {y}");
}

Это выражение:

{
    let x = 3;
    x + 1
}

— это блок, который в данном случае вычисляется в 4. Это значение привязывается к y в рамках оператора let. Обратите внимание на строку x + 1 без точки с запятой в конце, что отличается от большинства строк, виденных до сих пор. Выражения не включают завершающую точку с запятой. Если добавить точку с запятой в конец выражения, оно превратится в оператор и перестанет возвращать значение. Помните об этом при дальнейшем изучении возвращаемых значений функций и выражений.

Функции с возвращаемыми значениями

Функции могут возвращать значения коду, который их вызывает. Возвращаемые значения не именуются, но их тип нужно объявить после стрелки (->). В Rust возвращаемое значение функции равнозначно значению последнего выражения в блоке тела функции. Можно выполнить ранний возврат из функции с помощью ключевого слова return и указания значения, но большинство функций неявно возвращают последнее выражение. Вот пример функции, возвращающей значение:

Имя файла: src/main.rs

fn five() -> i32 {
    5
}

fn main() {
    let x = five();

    println!("The value of x is: {x}");
}

В функции five нет ни вызовов функций, ни макросов, ни даже операторов let — только число 5 само по себе. Это совершенно допустимая функция в Rust. Обратите внимание, что тип возвращаемого значения функции также указан, как -> i32. Попробуйте запустить этот код; вывод должен выглядеть так:

$ cargo run
   Compiling functions v0.1.0 (file:///projects/functions)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.30s
     Running `target/debug/functions`
The value of x is: 5

5 в функции five является возвращаемым значением функции, поэтому тип возвращаемого значения — i32. Рассмотрим это подробнее. Есть два важных момента: Во-первых, строка let x = five(); показывает, что возвращаемое значение функции используется для инициализации переменной. Поскольку функция five возвращает 5, эта строка эквивалентна следующей:

#![allow(unused)]
fn main() {
let x = 5;
}

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

Рассмотрим ещё один пример:

Имя файла: src/main.rs

fn main() {
    let x = plus_one(5);

    println!("The value of x is: {x}");
}

fn plus_one(x: i32) -> i32 {
    x + 1
}

Запуск этого кода выведет The value of x is: 6. Но что произойдёт, если поставить точку с запятой в конце строки, содержащей x + 1, превратив её из выражения в оператор?

Имя файла: src/main.rs

fn main() {
    let x = plus_one(5);

    println!("The value of x is: {x}");
}

fn plus_one(x: i32) -> i32 {
    x + 1;
}

Компиляция этого кода приведёт к ошибке, как показано ниже:

$ cargo run
   Compiling functions v0.1.0 (file:///projects/functions)
error[E0308]: mismatched types
 --> src/main.rs:7:24
  |
7 | fn plus_one(x: i32) -> i32 {
  |    --------            ^^^ expected `i32`, found `()`
  |    |
  |    implicitly returns `()` as its body has no tail or `return` expression
8 |     x + 1;
  |          - help: remove this semicolon to return this value

For more information about this error, try `rustc --explain E0308`.
error: could not compile `functions` (bin "functions") due to 1 previous error

Основное сообщение об ошибке mismatched types раскрывает суть проблемы с этим кодом. Определение функции plus_one говорит, что она вернёт i32, но операторы не вычисляются в значение, что выражается как (), единичный тип. Следовательно, ничего не возвращается, что противоречит определению функции и приводит к ошибке. В этом выводе Rust предоставляет сообщение, которое может помочь исправить эту проблему: предлагается удалить точку с запятой, что исправило бы ошибку.