Перейти к основному содержимому

Управляющие конструкции и циклы в Rust

Play ITЗагрузка интерактивного демо…

ОБЯЗАТЕЛЬНОДЛЯ НОВИЧКОВ
Разработчику Архитектору

О чём эта статья​

if, исчерпывающий match, циклы и операторы. В Rust многие конструкции — выражения с возвращаемым значением. Отдельный акцент на match с Option и Result.

Дальше: обработка ошибок.

Перед чтением: Операторы — общие понятия оператора, операнда, приоритетов и типов операций без привязки к языку.

Сначала: Циклы в коде — общая идея повторений, виды циклов и типичные ошибки без привязки к синтаксису языка.

Общее понимание операторов​

Play ITЗагрузка интерактивного демо…

Операторы Rust — те же категории, что в общей статье — арифметика, сравнение, логика, присваивание. Отличие языка: if и match — выражения (возвращают значение), поэтому можно писать let x = if cond { 1 } else { 2 };. Присваивание (=) выражением не является — его нельзя вкладывать в цепочку как в C.

Rust делит операторы на несколько категорий в зависимости от их назначения и количества операндов:

  • Унарные операторы работают с одним операндом.
  • Бинарные операторы требуют два операнда.
  • Существуют также специальные формы, такие как операторы присваивания и составные операторы, которые сочетают в себе несколько действий.

Рассмотрим каждую группу подробно.

Арифметические операторы​

Арифметические операторы в Rust предназначены для выполнения базовых математических операций — сложения, вычитания, умножения, деления и получения остатка от деления. Эти операторы работают с числовыми типами данных, такими как целые (i32, u64 и другие) и вещественные (f32, f64).

Код ITЗагрузка примера кода…

Разбор:

  • Пример показывает базовую арифметику (+) и безопасную проверку переполнения через checked_add.
  • u32::MAX — максимальное значение типа u32; добавление 1 может выйти за диапазон.
  • checked_add(1) возвращает Option<u32>: Some при успехе, None при переполнении.
  • match исчерпывающе обрабатывает оба сценария, избегая паники и неопределенного поведения.

Сложение обозначается символом +. Например, выражение 5 + 3 возвращает значение 8. Вычитание использует символ -, умножение — *, деление — /. Все эти операции возвращают результат того же типа, что и операнды, при условии, что они совпадают по типу. Если типы различаются, требуется явное преобразование.

Особое внимание заслуживает оператор получения остатка от деления %. Он возвращает остаток после целочисленного деления одного числа на другое. Например, 10 % 3 даёт 1, потому что 10 делится на 3 три раза с остатком 1. Этот оператор особенно полезен при работе с циклическими структурами, проверке чётности чисел или распределении элементов по группам.

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

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

Операторы сравнения позволяют сравнивать два значения и получать логический результат — true или false. В Rust поддерживаются следующие операторы сравнения:

  • == — равенство
  • != — неравенство
  • < — меньше
  • > — больше
  • <= — меньше или равно
  • >= — больше или равно

Эти операторы применимы к любым типам, реализующим соответствующие трейты, такие как PartialEq для равенства и PartialOrd для упорядочения. Большинство встроенных типов, включая числа, строки и булевы значения, уже реализуют эти трейты, поэтому их можно сравнивать напрямую.

Результат сравнения часто используется в условных выражениях и циклах для управления логикой программы. Например, конструкция if x > 10 { ... } выполняет блок кода только тогда, когда значение переменной x превышает 10.

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

let age = 20;
let has_ticket = true;

let can_enter = age >= 18 && has_ticket;
let is_child = age < 13;

println!("Вход: {}, ребёнок: {}", can_enter, is_child);

Разбор:

  • Операторы >=, < возвращают bool, который можно сохранить в переменную.
  • && объединяет два условия: оба должны быть истинны для can_enter.
  • is_child показывает простое сравнение без логического И.
  • Такой код удобно использовать как вход в if, while или match.

Логические операторы​

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

  • && — логическое И
  • || — логическое ИЛИ
  • ! — логическое НЕ

Оператор && возвращает true, только если оба операнда равны true. Оператор || возвращает true, если хотя бы один из операндов равен true. Оператор ! инвертирует значение: !true даёт false, а !false — true.

Важной особенностью логических операторов в Rust является ленивое вычисление (short-circuit evaluation). Это означает, что правый операнд не вычисляется, если результат уже определён по левому. Например, в выражении a && b, если a равно false, то b не будет вычисляться, потому что общий результат уже известен. Аналогично, в выражении a || b, если a равно true, то b игнорируется. Это поведение повышает эффективность и позволяет избегать ошибок, например, при проверке наличия значения перед обращением к нему.

// Пример 2: Логические операторы с ленивым вычислением
fn check_user_access(user_id: Option<u32>, is_admin: bool) -> bool {
    user_id.map_or(false, |id| id > 100) || is_admin
}

fn main() {
    let result1 = check_user_access(Some(150), false); // true
    let result2 = check_user_access(None, false);      // false
    let result3 = check_user_access(None, true);       // true
    
    println!("Доступ: {}, {}, {}", result1, result2, result3);
}

Разбор:

  • Функция принимает Option<u32> и bool, возвращая итоговый флаг доступа.
  • map_or(false, |id| id > 100) проверяет условие только если user_id содержит Some(id).
  • Оператор || объединяет правило "id > 100" с флагом администратора.
  • В main три вызова демонстрируют разные ветки логики и итоговые значения true/false.

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

Побитовые операторы​

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

Rust поддерживает следующие побитовые операторы:

  • & — побитовое И
  • | — побитовое ИЛИ
  • ^ — побитовое исключающее ИЛИ (XOR)
  • ! — побитовое НЕ (инверсия всех битов)
  • &lt;&lt; — сдвиг влево
  • &gt;&gt; — сдвиг вправо

Операторы сдвига перемещают биты числа в указанном направлении. При сдвиге влево младшие биты заполняются нулями, а старшие теряются. При сдвиге вправо поведение зависит от знака числа — для беззнаковых типов (u32, u64) используются нули, для знаковых (i32, i64) — знаковый бит (арифметический сдвиг).

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

let flags: u8 = 0b0000_0101;
let mask_read: u8 = 0b0000_0001;
let mask_write: u8 = 0b0000_0010;

let can_read = (flags & mask_read) != 0;
let can_write = (flags & mask_write) != 0;
let toggled = flags ^ 0b0000_0001; // инверсия младшего бита

println!("read={}, write={}, toggled={:08b}", can_read, can_write, toggled);

Разбор:

  • & применяется как побитовое И для проверки установленных битов-флагов.
  • mask_read и mask_write выделяют отдельные права в одном байте.
  • ^ (XOR) переключает бит: 1 становится 0, 0 становится 1.
  • &#123;:08b&#125; в println! печатает число в двоичном виде с ведущими нулями.

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

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

Существуют также составные операторы присваивания, которые объединяют арифметическую или побитовую операцию с присваиванием:

  • +=
  • -=
  • *=
  • /=
  • %=
  • &=
  • |=
  • ^=
  • &lt;&lt;=
  • &gt;&gt;=

Например, запись x += 5 эквивалентна x = x + 5. Эти операторы удобны для сокращения кода и повышения его читаемости. Они требуют, чтобы переменная была изменяемой, иначе компилятор выдаст ошибку.

let mut points = 0;
points += 10;
points *= 2;
points -= 3;
println!("Итоговые очки: {}", points); // 17

Разбор:

  • points объявлен как mut, иначе операторы +=, *=, -= недоступны.
  • Каждый составной оператор изменяет текущее значение "на месте".
  • Порядок операций важен — сначала +10, затем *2, затем -3.
  • Это типичный паттерн накопления состояния в циклах и игровой логике.

Условные конструкции: if и match​

if и match в Rust — полноценные выражения: они могут возвращать значение, которое присваивается переменной. Для Option и Result это основной способ безопасно разбирать данные.

Код ITЗагрузка примера кода…

Разбор:

  • Функция classify возвращает &'static str, потому что литералы живут в бинарнике.
  • Ветки if/else if/else возвращают значения одного типа.
  • Последнее выражение в функции без ; становится возвращаемым значением.
  • Такой стиль делает ветвление компактным и типобезопасным.

Код ITЗагрузка примера кода…

Разбор:

  • divide возвращает Option<i32> вместо "магического" -1 при ошибке.
  • Some(value) и None — два варианта enum Option.
  • match обязан обработать оба случая, иначе компилятор выдаст ошибку.
  • Это базовый шаблон перед переходом к Result и обработке ошибок в следующей главе.

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

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

let y = {
    let x = 3;
    x + 1
};

Разбор:

  • Блок { ... } в Rust является выражением и может возвращать значение.
  • Внутренний x существует только внутри блока (локальная область видимости).
  • Последняя строка без ; (x + 1) становится возвращаемым значением блока.
  • Поэтому y получает 4 без отдельного return.

Здесь блок { ... } является выражением, и его результат — значение 4 — присваивается переменной y. Аналогично, арифметические и логические операторы возвращают результат, который может быть частью более сложного выражения.

Однако оператор присваивания = сам по себе не возвращает полезного значения. Его тип — () (unit type), что означает "отсутствие значения". Это сделано намеренно, чтобы избежать распространённой ошибки из других языков, где случайное использование = вместо == в условии приводит к неожиданному поведению. В Rust такое условие не скомпилируется, если только не используется специальный синтаксис.

Интерактивное демо — пошаговый цикл на примере JavaScript (for, while). В Rust синтаксис другой, но порядок шагов тот же. Обобщённо: циклы в коде.

Play ITЗагрузка интерактивного демо…

Циклы в Rust — повторение без компромиссов​

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

Rust предоставляет три основные формы циклов:

  • loop — бесконечный цикл, прерываемый явно;
  • while — цикл с предусловием;
  • for — цикл по итератору.

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

Бесконечный цикл loop​

Самый простой и фундаментальный цикл в Rust — это loop. Он представляет собой бесконечную последовательность повторений, которая продолжается до тех пор, пока не будет явно прервана с помощью ключевого слова break.

loop {
    println!("Это будет печататься вечно...");
    break; // Без этого цикл действительно будет бесконечным
}

Разбор:

  • loop запускает бесконечный цикл без встроенного условия завершения.
  • break принудительно останавливает цикл в нужной точке.
  • Без break (или return) цикл действительно не завершится.
  • Такой шаблон применяют, когда условие выхода вычисляется внутри тела цикла.

Хотя на первый взгляд такой цикл может показаться примитивным, он играет важную роль в системном программировании, реализации событийных циклов, игровых движков, сетевых серверов и других сценариев, где логика завершения не сводится к простому условию. Например, сервер может использовать loop для постоянного ожидания входящих соединений, а каждое соединение обрабатывается внутри тела цикла.

Особенность loop в том, что он может возвращать значение. Это достигается путём указания выражения после break:

let result = loop {
    let x = some_computation();
    if x > 100 {
        break x * 2;
    }
};

Разбор:

  • Этот loop используется как выражение, возвращающее значение через break x * 2.
  • some_computation() вызывается на каждой итерации до выполнения условия x > 100.
  • После break цикл завершится, а вычисленное значение присвоится result.
  • Паттерн удобен для "ожидания события" или "поиска первого подходящего результата".

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

Код ITЗагрузка примера кода…

Разбор:

  • Функция ищет первое четное число от 0 до limit и возвращает Option<i32>.
  • Внутри loop есть два сценария выхода — return None, если предел превышен, и break Some(num) при успехе.
  • Проверка num % 2 == 0 использует остаток от деления для теста четности.
  • В main конструкция if let Some(number) аккуратно обрабатывает найденное значение.

Условный цикл while​

Цикл while выполняет тело до тех пор, пока заданное логическое выражение остаётся истинным. Проверка условия происходит перед каждой итерацией, поэтому если условие изначально ложно, тело цикла не выполнится ни разу.

let mut counter = 0;
while counter < 5 {
    println!("Счётчик: {}", counter);
    counter += 1;
}

Разбор:

  • mut нужен, потому что счетчик изменяется на каждой итерации.
  • while проверяет условие counter < 5 перед каждым проходом.
  • counter += 1 сдвигает состояние цикла к завершению.
  • Это классический цикл с предусловием, когда критерий остановки выражен булевым условием.

Этот цикл удобен, когда количество итераций заранее неизвестно, но существует чёткий критерий завершения — например, ожидание ввода пользователя, чтение данных из потока до конца или обработка состояния, которое изменяется во время выполнения.

Код ITЗагрузка примера кода…

Разбор:

  • countdown инициализирует локальный счетчик значением start.
  • Цикл while counter >= 0 печатает обратный отсчет до нуля включительно.
  • После каждой итерации counter -= 1 уменьшает значение и приближает выход.
  • После завершения цикла печатается финальное сообщение "Поехали!".

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

Итерационный цикл for​

Цикл for в Rust — это не просто синтаксический сахар для инкрементного счётчика. Он является универсальным механизмом итерации по любым типам, реализующим трейт IntoIterator. Это включает массивы, векторы, диапазоны, строки, хэш-карты и пользовательские коллекции.

Простейший пример — итерация по диапазону:

for i in 1..=5 {
    println!("{}", i);
}

Разбор:

  • 1..=5 — включающий диапазон, поэтому цикл выполнится для 1,2,3,4,5.
  • for последовательно берет значения из итератора диапазона.
  • Переменная i создается на каждой итерации как новое связывание.
  • Это идиоматичный и безопасный способ обхода последовательности в Rust.

Здесь 1..=5 — это включающий диапазон от 1 до 5. Если бы использовался 1..5, цикл выполнился бы для значений от 1 до 4.

Итерация по вектору:

let numbers = vec![10, 20, 30];
for num in numbers {
    println!("{}", num);
}

Разбор:

  • vec![...] создает вектор в куче с тремя элементами.
  • for num in numbers вызывает into_iter() и перемещает элементы во владение цикла.
  • После такого обхода исходный numbers больше нельзя использовать.
  • Это поведение напрямую связано с моделью ownership.

В этом случае переменная num получает владение каждым элементом вектора. После завершения цикла сам вектор numbers становится недоступным, потому что его содержимое было перемещено в тело цикла. Это следствие модели владения: данные не копируются без необходимости, а передаются напрямую.

Если требуется только чтение элементов без передачи владения, используется заимствование:

let numbers = vec![10, 20, 30];
for num in &numbers {
    println!("{}", num);
}
// numbers всё ещё доступен здесь

Разбор:

  • &numbers создает неизменяемое заимствование коллекции для итерации.
  • Внутри цикла num имеет тип &i32, а не i32.
  • Владение вектором не передается, поэтому numbers можно использовать после цикла.
  • Это стандартный паттерн "прочитать элементы без изменения коллекции".

Аналогично, можно получить изменяемые ссылки с помощью &mut.

Для получения одновременно индекса и значения применяется метод .enumerate():

let fruits = ["яблоко", "банан", "апельсин"];
for (index, fruit) in fruits.iter().enumerate() {
    println!("{}: {}", index, fruit);
}

Разбор:

  • iter() создает итератор по ссылкам на элементы массива.
  • enumerate() добавляет индекс к каждому элементу, образуя пары (usize, &str).
  • Деструктуризация (index, fruit) распаковывает пару прямо в заголовке цикла.
  • Подход безопасен: индексы генерируются итератором, а не считаются вручную.

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

Управление потоком внутри циклов — break и continue​

Rust предоставляет два ключевых слова для управления выполнением циклов:

  • break — немедленно прекращает выполнение цикла;
  • continue — прерывает текущую итерацию и переходит к следующей.

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

for n in 1..=10 {
    if n % 2 != 0 {
        continue; // пропускаем нечётные
    }
    if n > 6 {
        break; // выходим, когда дошли до 8
    }
    println!("чётное: {}", n);
}

Разбор:

  • Цикл for n in 1..=10 перебирает числа от 1 до 10 включительно.
  • continue переходит к следующей итерации, не выполняя println! для нечётных.
  • break завершает цикл полностью при n > 6 (то есть после печати 2, 4, 6).
  • Комбинация continue + break — стандартный способ фильтрации и раннего выхода.
'outer: for x in 0..3 {
    'inner: for y in 0..3 {
        if x == 1 && y == 1 {
            break 'outer;
        }
        println!("({}, {})", x, y);
    }
}

Разбор:

  • 'outer и 'inner — метки циклов для точного управления вложенными обходами.
  • break 'outer прерывает внешний цикл сразу, минуя оставшиеся итерации внутреннего.
  • Условие x == 1 && y == 1 определяет момент досрочного выхода.
  • Такой механизм полезен в поисковых алгоритмах по двум измерениям.

Без метки break прервал бы только внутренний цикл. С меткой 'outer — внешний. Это мощный, но редко используемый механизм, который сохраняет читаемость даже в сложных вложенных структурах.

Циклы и безопасность памяти​

Одна из ключевых особенностей Rust — отсутствие неопределённого поведения при работе с памятью. Эта гарантия распространяется и на циклы. Например, попытка изменить коллекцию во время её итерации приведёт к ошибке компиляции:

let mut vec = vec![1, 2, 3];
for item in &vec {
    vec.push(*item); // Ошибка: нельзя одновременно заимствовать как неизменяемую и изменяемую ссылку
}

Разбор:

  • for item in &vec создает неизменяемое заимствование вектора на время итерации.
  • vec.push(...) требует изменяемое заимствование того же вектора.
  • Одновременное & и &mut к одному объекту запрещено borrow checker-ом.
  • Ошибка появляется на этапе компиляции, предотвращая потенциальную порчу структуры данных.

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

Производительность циклов​

Циклы в Rust компилируются в высокоэффективный машинный код, сравнимый с C или C++. Это достигается благодаря:

  • отсутствию накладных расходов на сборку мусора;
  • агрессивной оптимизации со стороны LLVM;
  • возможности инлайнинга итераторов;
  • возможной элиминации проверок границ в release только когда компилятор доказывает безопасность индекса; индексация arr[i] в safe-коде по-прежнему паникует при выходе за границы, если проверка не убрана оптимизатором.

На практике идиоматичный Rust-код с for и итераторами часто оказывается быстрее, чем аналогичный код с ручным управлением индексами, поскольку компилятор лучше понимает намерения программиста и может применять более глубокие оптимизации.

Итераторы — основа повторяющихся вычислений​

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

Любой тип, реализующий трейт Iterator, может быть использован в цикле for. Трейт Iterator требует реализации одного метода — next(), который возвращает Option<Self::Item>. Значение Some(item) означает, что следующий элемент доступен, а None сигнализирует об окончании последовательности.

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

Создание и использование итераторов​

Итераторы создаются вызовом методов, таких как .iter(), .into_iter(), .chars(), .lines() или просто через диапазоны:

let v = vec![1, 2, 3];
let mut iter = v.iter(); // возвращает итератор по ссылкам

Разбор:

  • v.iter() создает итератор, выдающий &i32 для каждого элемента вектора.
  • mut iter нужен, потому что вызовы next() изменяют внутреннее состояние итератора.
  • Владелец данных (v) сохраняется, так как используется заимствование.
  • Это базовый уровень работы с итераторами "вручную", без for.

Метод .iter() заимствует элементы, .into_iter() передаёт владение, а .iter_mut() предоставляет изменяемые ссылки. Выбор метода определяет, будет ли исходная коллекция доступна после итерации и можно ли изменять её содержимое.

Цикл for автоматически вызывает .into_iter() на правом операнде, поэтому запись:

for x in collection { ... }

Разбор:

  • Это сокращенная форма итерации по типу, реализующему IntoIterator.
  • Компилятор разворачивает ее в использование итератора и последовательные вызовы next().
  • Конкретный режим владения зависит от того, что именно передано справа (collection, &collection, &mut collection).
  • Такой синтаксис делает код компактным без потери типовой строгости.

эквивалентна:

for x in collection.into_iter() { ... }

Разбор:

  • Здесь явно показан вызов into_iter(), который преобразует коллекцию в итератор.
  • Для владеющего значения это обычно передача владения элементами.
  • Эквивалент помогает понять, почему после некоторых for коллекция больше недоступна.
  • Явная форма полезна в обучении и сложных generic-сценариях.

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

Комбинаторы итераторов — функциональный подход к потокам данных​

Rust предоставляет богатый набор комбинаторов итераторов — методов, которые преобразуют, фильтруют, объединяют или агрегируют данные без немедленного выполнения. Такие операции являются ленивыми — они не вычисляются до тех пор, пока не будет вызван "потребляющий" метод, такой как .collect(), .fold() или явный цикл.

Некоторые из наиболее часто используемых комбинаторов:

  • .map(f) — применяет функцию f к каждому элементу;
  • .filter(p) — оставляет только те элементы, для которых предикат p возвращает true;
  • .take(n) — ограничивает количество элементов до n;
  • .skip(n) — пропускает первые n элементов;
  • .enumerate() — добавляет индекс к каждому элементу;
  • .zip(other) — объединяет два итератора в пары;
  • .fold(init, f) — сворачивает последовательность в одно значение, начиная с init.

Пример композиции:

let result: Vec<i32> = (1..10)
    .filter(|x| x % 2 == 0)
    .map(|x| x * x)
    .collect();
// result = [4, 16, 36, 64]

Разбор:

  • Цепочка итераторов лениво описывает pipeline обработки данных.
  • filter оставляет только четные значения, map преобразует каждое в квадрат.
  • collect() материализует результат в Vec<i32>, поэтому вычисления реально выполняются.
  • Такой код обычно читается как декларативное описание трансформаций.

Этот код читается как последовательность трансформаций — сначала берутся числа от 1 до 9, затем отбираются чётные, после чего каждое возводится в квадрат, и результат собирается в вектор. Такой стиль программирования близок к декларативному: он описывает что нужно сделать, а не как это сделать шаг за шагом.

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

Потребление итераторов — когда вычисления становятся реальными​

Ленивость итераторов означает, что создание цепочки .map().filter().take() не приводит к немедленной обработке данных. Вычисления запускаются только при вызове метода, который "потребляет" итератор:

  • .collect() — собирает все элементы в коллекцию (например, Vec, String, HashSet);
  • .fold() — сворачивает последовательность в одно значение;
  • .for_each() — выполняет побочный эффект для каждого элемента;
  • .last(), .nth(), .find() — извлекают конкретные элементы;
  • .count() — подсчитывает количество элементов.

Выбор потребляющего метода определяет, как будет использован результат итерации. Например, если требуется только проверить наличие хотя бы одного подходящего элемента, достаточно вызвать .any(|x| condition), и итерация прекратится сразу после первого совпадения.

Обработка ошибок в итераторах​

Итераторы в Rust могут работать с типами, содержащими ошибки, такими как Result<T, E>. Для этого существуют специальные комбинаторы:

  • .collect::<Result<Vec<_>, _&gt;&gt;() — собирает все Ok значения, но прерывается и возвращает первую Err;
  • .filter_map() — преобразует и одновременно отфильтровывает, возвращая Option;
  • .try_for_each() — выполняет действие для каждого элемента, но останавливается при первой ошибке.

Эти инструменты позволяют естественно интегрировать обработку ошибок в потоки данных, не нарушая линейности кода и не прибегая к вложенным match или if let.

Итераторы и владение — гарантии безопасности​

Модель владения Rust проявляется и в работе с итераторами. Невозможно одновременно иметь изменяемый итератор и неизменяемую ссылку на коллекцию. Невозможно получить доступ к элементу по индексу, если коллекция уже передана во владение итератору. Эти ограничения обеспечивают отсутствие гонок данных, двойного освобождения памяти и использования после освобождения — даже в многопоточной среде.

Кроме того, итераторы не хранят внутренние указатели на данные после завершения. Они либо владеют данными, либо заимствуют их на время, ограниченное временем жизни ('a). Это делает их совместимыми с системой проверки времени жизни и исключает утечки.

Асинхронные итераторы — будущее повторяющихся операций​

Хотя стандартная библиотека Rust на момент 2026 года не включает встроенную поддержку асинхронных итераторов, экосистема предлагает решения через крейты, такие как futures и tokio-stream. Асинхронный итератор (Stream) — это аналог Iterator, но его метод next() возвращает Poll<Option<T&gt;&gt; или Pin<Box<dyn Future<Output = Option<T&gt;&gt;&gt;&gt;, в зависимости от реализации.

Асинхронные циклы записываются с помощью while let Some(item) = stream.next().await { ... }, а в будущем могут получить синтаксическую поддержку в виде for await. Это открывает путь к эффективной обработке потоков данных из сетевых соединений, баз данных или сенсоров без блокировки выполнения.

Содержание