Сочетания клавиш

Нажмите ← или → для навигации между главами

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

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

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

Поток управления

Возможность выполнять некоторый код в зависимости от того, истинно ли условие (true), и возможность повторять выполнение кода, пока условие истинно, — это базовые строительные блоки в большинстве языков программирования. Наиболее распространённые конструкции, позволяющие управлять потоком выполнения кода в Rust, — это выражения if и циклы.

Выражения if

Выражение if позволяет ветвить код в зависимости от условий. Вы задаёте условие и затем указываете: «Если это условие выполняется, выполнить этот блок кода. Если условие не выполняется, не выполнять этот блок кода».

Создайте новый проект под названием branches в вашем каталоге projects, чтобы исследовать выражение if. В файл src/main.rs введите следующее:

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

fn main() {
    let number = 3;

    if number < 5 {
        println!("condition was true");
    } else {
        println!("condition was false");
    }
}

Все выражения if начинаются с ключевого слова if, за которым следует условие. В данном случае условие проверяет, имеет ли переменная number значение меньше 5. Блок кода, который нужно выполнить, если условие истинно, мы размещаем сразу после условия внутри фигурных скобок. Блоки кода, связанные с условиями в выражениях if, иногда называют ветвями, точно так же, как ветви в выражениях match, которые мы обсуждали в разделе «Сравнение догадки с секретным числом» главы 2.

При желании мы также можем включить выражение else, что мы и решили сделать здесь, чтобы дать программе альтернативный блок кода для выполнения в случае, если условие вычислится как false. Если вы не предоставите выражение else и условие окажется false, программа просто пропустит блок if и перейдёт к следующему фрагменту кода.

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

$ cargo run
   Compiling branches v0.1.0 (file:///projects/branches)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.31s
     Running `target/debug/branches`
condition was true

Давайте попробуем изменить значение number на такое, при котором условие станет false, чтобы увидеть, что произойдёт:

fn main() {
    let number = 7;

    if number < 5 {
        println!("condition was true");
    } else {
        println!("condition was false");
    }
}

Запустите программу снова и посмотрите на вывод:

$ cargo run
   Compiling branches v0.1.0 (file:///projects/branches)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.31s
     Running `target/debug/branches`
condition was false

Также стоит отметить, что условие в этом коде должно иметь тип bool. Если условие не является bool, мы получим ошибку. Например, попробуйте запустить следующий код:

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

fn main() {
    let number = 3;

    if number {
        println!("number was three");
    }
}

Условие if в этот раз вычисляется в значение 3, и Rust выдаёт ошибку:

$ cargo run
   Compiling branches v0.1.0 (file:///projects/branches)
error[E0308]: mismatched types
 --> src/main.rs:4:8
  |
4 |     if number {
  |        ^^^^^^ expected `bool`, found integer

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

Ошибка указывает на то, что Rust ожидал bool, но получил целое число. В отличие от таких языков, как Ruby и JavaScript, Rust не будет автоматически пытаться преобразовать небулевы типы в булевы. Вы должны быть явными и всегда предоставлять if условие типа Boolean. Если мы хотим, чтобы блок кода if выполнялся только тогда, когда число не равно 0, например, мы можем изменить выражение if на следующее:

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

fn main() {
    let number = 3;

    if number != 0 {
        println!("number was something other than zero");
    }
}

Выполнение этого кода выведет number was something other than zero.

Обработка нескольких условий с помощью else if

Вы можете использовать несколько условий, комбинируя if и else в выражении else if. Например:

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

fn main() {
    let number = 6;

    if number % 4 == 0 {
        println!("number is divisible by 4");
    } else if number % 3 == 0 {
        println!("number is divisible by 3");
    } else if number % 2 == 0 {
        println!("number is divisible by 2");
    } else {
        println!("number is not divisible by 4, 3, or 2");
    }
}

У этой программы есть четыре возможных пути выполнения. После её запуска вы должны увидеть следующий вывод:

$ cargo run
   Compiling branches v0.1.0 (file:///projects/branches)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.31s
     Running `target/debug/branches`
number is divisible by 3

Когда эта программа выполняется, она по очереди проверяет каждое выражение if и выполняет первое тело, для которого условие вычисляется как true. Обратите внимание, что хотя 6 делится на 2, мы не видим вывод number is divisible by 2, как не видим и текст number is not divisible by 4, 3, or 2 из блока else. Это потому, что Rust выполняет блок только для первого истинного условия, и как только он его находит, он даже не проверяет остальные.

Использование слишком большого количества выражений else if может загромоздить ваш код, поэтому если у вас их больше одного, возможно, стоит провести рефакторинг. В главе 6 описана мощная конструкция ветвления Rust под названием match для таких случаев.

Использование if в инструкции let

Поскольку if является выражением, мы можем использовать его в правой части инструкции let, чтобы присвоить результат переменной, как в листинге 3-2.

Имя файла: src/main.rs
fn main() {
    let condition = true;
    let number = if condition { 5 } else { 6 };

    println!("The value of number is: {number}");
}
Листинг 3-2: Присвоение результата выражения if переменной

Переменная number будет привязана к значению на основе результата выражения if. Запустите этот код, чтобы увидеть, что произойдёт:

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

Помните, что блоки кода вычисляются в последнее выражение в них, а числа сами по себе также являются выражениями. В данном случае значение всего выражения if зависит от того, какой блок кода выполняется. Это означает, что значения, которые могут быть результатами каждой ветви if, должны быть одного типа; в листинге 3-2 результаты и ветви if, и ветви else были целыми числами i32. Если типы не совпадают, как в следующем примере, мы получим ошибку:

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

fn main() {
    let condition = true;

    let number = if condition { 5 } else { "six" };

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

Когда мы попытаемся скомпилировать этот код, мы получим ошибку. Ветви if и else имеют несовместимые типы значений, и Rust точно указывает, где искать проблему в программе:

$ cargo run
   Compiling branches v0.1.0 (file:///projects/branches)
error[E0308]: `if` and `else` have incompatible types
 --> src/main.rs:4:44
  |
4 |     let number = if condition { 5 } else { "six" };
  |                                 -          ^^^^^ expected integer, found `&str`
  |                                 |
  |                                 expected because of this

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

Выражение в блоке if вычисляется как целое число, а выражение в блоке else вычисляется как строка. Это не сработает, потому что переменные должны иметь один тип, а Rust должен точно знать во время компиляции, какой тип у переменной number. Знание типа number позволяет компилятору проверить, что тип действителен везде, где мы используем number. Rust не смог бы этого сделать, если бы тип number определялся только во время выполнения; компилятор был бы сложнее и давал бы меньше гарантий о коде, если бы ему приходилось отслеживать несколько гипотетических типов для любой переменной.

Повторение с помощью циклов

Часто бывает полезно выполнять блок кода более одного раза. Для этой задачи Rust предоставляет несколько циклов, которые будут выполнять код внутри тела цикла до конца, а затем немедленно начинать снова с начала. Чтобы поэкспериментировать с циклами, давайте создадим новый проект под названием loops.

В Rust есть три вида циклов: loop, while и for. Давайте попробуем каждый из них.

Повторение кода с помощью loop

Ключевое слово loop указывает Rust выполнять блок кода снова и снова либо бесконечно, либо до тех пор, пока вы явно не скажете ему остановиться.

В качестве примера измените файл src/main.rs в вашем каталоге loops так, чтобы он выглядел следующим образом:

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

fn main() {
    loop {
        println!("again!");
    }
}

Когда мы запустим эту программу, мы увидим, как again! выводится снова и снова, непрерывно, пока мы не остановим программу вручную. Большинство терминалов поддерживают сочетание клавиш ctrl-C, чтобы прервать программу, застрявшую в бесконечном цикле. Попробуйте:

$ cargo run
   Compiling loops v0.1.0 (file:///projects/loops)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.08s
     Running `target/debug/loops`
again!
again!
again!
again!
^Cagain!

Символ ^C обозначает место, где вы нажали ctrl-C.

Вы можете увидеть или не увидеть слово again!, напечатанное после ^C, в зависимости от того, где находился код в цикле, когда он получил сигнал прерывания.

К счастью, Rust также предоставляет способ выйти из цикла с помощью кода. Вы можете поместить ключевое слово break внутрь цикла, чтобы указать программе, когда прекратить выполнение цикла. Вспомните, что мы делали это в игре «Угадай число» в разделе «Выход после правильной догадки» главы 2, чтобы выйти из программы, когда пользователь выиграл игру, угадав правильное число.

Мы также использовали continue в игре «Угадай число», который в цикле говорит программе пропустить оставшийся код в этой итерации цикла и перейти к следующей итерации.

Возврат значений из циклов

Одно из применений loop — повторение операции, которая, как вы знаете, может завершиться неудачей, например, проверка того, завершил ли поток свою работу. Возможно, вам также потребуется передать результат этой операции из цикла остальной части вашего кода. Для этого вы можете добавить значение, которое хотите вернуть, после выражения break, используемого для остановки цикла; это значение будет возвращено из цикла, чтобы вы могли его использовать, как показано здесь:

fn main() {
    let mut counter = 0;

    let result = loop {
        counter += 1;

        if counter == 10 {
            break counter * 2;
        }
    };

    println!("The result is {result}");
}

Перед циклом мы объявляем переменную с именем counter и инициализируем её значением 0. Затем мы объявляем переменную с именем result, чтобы сохранить значение, возвращаемое из цикла. На каждой итерации цикла мы добавляем 1 к переменной counter, а затем проверяем, равна ли counter 10. Когда она равна, мы используем ключевое слово break со значением counter * 2. После цикла мы используем точку с запятой, чтобы завершить инструкцию, присваивающую значение result. Наконец, мы печатаем значение в result, которое в данном случае равно 20.

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

Устранение неоднозначности с помощью меток циклов

Если у вас есть циклы внутри циклов, break и continue применяются к самому внутреннему циклу в этой точке. При желании вы можете указать метку цикла на цикле, которую затем можно использовать с break или continue, чтобы указать, что эти ключевые слова применяются к помеченному циклу, а не к самому внутреннему. Метки циклов должны начинаться с одинарной кавычки. Вот пример с двумя вложенными циклами:

fn main() {
    let mut count = 0;
    'counting_up: loop {
        println!("count = {count}");
        let mut remaining = 10;

        loop {
            println!("remaining = {remaining}");
            if remaining == 9 {
                break;
            }
            if count == 2 {
                break 'counting_up;
            }
            remaining -= 1;
        }

        count += 1;
    }
    println!("End count = {count}");
}

Внешний цикл имеет метку 'counting_up, и он будет считать от 0 до 2. Внутренний цикл без метки считает вниз от 10 до 9. Первый break, не указывающий метку, выйдет только из внутреннего цикла. Инструкция break 'counting_up; выйдет из внешнего цикла. Этот код печатает:

$ cargo run
   Compiling loops v0.1.0 (file:///projects/loops)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.58s
     Running `target/debug/loops`
count = 0
remaining = 10
remaining = 9
count = 1
remaining = 10
remaining = 9
count = 2
remaining = 10
End count = 2

Упрощение условных циклов с помощью while

Программе часто требуется вычислять условие внутри цикла. Пока условие истинно (true), цикл выполняется. Когда условие перестаёт быть истинным (true), программа вызывает break, останавливая цикл. Можно реализовать такое поведение, используя комбинацию loop, if, else и break; вы можете попробовать это сейчас в программе, если хотите. Однако этот шаблон настолько распространён, что в Rust есть встроенная языковая конструкция для него, называемая циклом while. В листинге 3-3 мы используем while, чтобы зациклить программу три раза, каждый раз выполняя обратный отсчёт, а затем, после цикла, напечатать сообщение и выйти.

Имя файла: src/main.rs
fn main() {
    let mut number = 3;

    while number != 0 {
        println!("{number}!");

        number -= 1;
    }

    println!("LIFTOFF!!!");
}
Листинг 3-3: Использование цикла while для выполнения кода, пока условие вычисляется как true

Эта конструкция устраняет большую часть вложенности, которая была бы необходима при использовании loop, if, else и break, и она понятнее. Пока условие вычисляется как true, код выполняется; в противном случае он выходит из цикла.

Цикл по коллекции с помощью for

Вы можете использовать конструкцию while для перебора элементов коллекции, такой как массив. Например, цикл в листинге 3-4 печатает каждый элемент массива a.

Имя файла: src/main.rs
fn main() {
    let a = [10, 20, 30, 40, 50];
    let mut index = 0;

    while index < 5 {
        println!("the value is: {}", a[index]);

        index += 1;
    }
}
Листинг 3-4: Перебор каждого элемента коллекции с использованием цикла while

Здесь код проходит по элементам массива. Он начинается с индекса 0, а затем зацикливается, пока не достигнет последнего индекса в массиве (то есть пока index < 5 не перестанет быть true). Выполнение этого кода напечатает каждый элемент массива:

$ cargo run
   Compiling loops v0.1.0 (file:///projects/loops)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.32s
     Running `target/debug/loops`
the value is: 10
the value is: 20
the value is: 30
the value is: 40
the value is: 50

Все пять значений массива появляются в терминале, как и ожидалось. Несмотря на то, что index в какой-то момент достигнет значения 5, цикл прекращает выполнение, прежде чем попытаться получить шестое значение из массива.

Однако этот подход подвержен ошибкам; мы могли бы вызвать панику программы, если значение индекса или условие проверки неверны. Например, если вы измените определение массива a на четыре элемента, но забудете обновить условие до while index < 4, код запаникует. Это также медленно, потому что компилятор добавляет код времени выполнения для выполнения условной проверки того, находится ли индекс в границах массива на каждой итерации цикла.

В качестве более краткой альтернативы вы можете использовать цикл for и выполнять некоторый код для каждого элемента в коллекции. Цикл for выглядит как код в листинге 3-5.

Имя файла: src/main.rs
fn main() {
    let a = [10, 20, 30, 40, 50];

    for element in a {
        println!("the value is: {element}");
    }
}
Листинг 3-5: Перебор каждого элемента коллекции с использованием цикла for

Когда мы запустим этот код, мы увидим тот же вывод, что и в листинге 3-4. Что ещё важнее, теперь мы повысили безопасность кода и устранили возможность ошибок, которые могут возникнуть из-за выхода за пределы массива или недостаточного продвижения и пропуска некоторых элементов. Машинный код, генерируемый из циклов for, также может быть более эффективным, потому что индекс не нужно сравнивать с длиной массива на каждой итерации.

Используя цикл for, вам не нужно было бы помнить об изменении любого другого кода, если бы вы изменили количество значений в массиве, как это было бы с методом, использованным в листинге 3-4.

Безопасность и краткость циклов for делают их наиболее часто используемой конструкцией цикла в Rust. Даже в ситуациях, когда вы хотите выполнить некоторый код определённое количество раз, как в примере с обратным отсчётом, в котором использовался цикл while в листинге 3-3, большинство Rustaceans использовали бы цикл for. Способ сделать это — использовать Range, предоставляемый стандартной библиотекой, который генерирует все числа в последовательности, начиная с одного числа и заканчивая перед другим числом.

Вот как выглядел бы обратный отсчёт с использованием цикла for и другого метода, о котором мы ещё не говорили, rev, для обращения диапазона:

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

fn main() {
    for number in (1..4).rev() {
        println!("{number}!");
    }
    println!("LIFTOFF!!!");
}

Этот код немного приятнее, не так ли?

Резюме

Вы справились! Это была довольно объёмная глава: вы узнали о переменных, скалярных и составных типах данных, функциях, комментариях, выражениях if и циклах! Чтобы попрактиковаться в концепциях, обсуждавшихся в этой главе, попробуйте построить программы, которые делают следующее:

  • Преобразование температур между Фаренгейтом и Цельсием.
  • Генерация n-го числа Фибоначчи.
  • Печать текста рождественской песни «Двенадцать дней Рождества», используя повторение в песне.

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