Обработка последовательности элементов с помощью итераторов
Паттерн итератора позволяет поочерёдно выполнять некоторую задачу над последовательностью элементов. Итератор отвечает за логику перебора каждого элемента и определение того, когда последовательность закончилась. При использовании итераторов не нужно самому заново реализовывать эту логику.
В Rust итераторы ленивы, то есть они не производят никакого эффекта, пока не будут вызваны
методы, потребляющие итератор. Например, код в
листинге 13-10 создаёт итератор по элементам вектора v1 путём вызова
метода iter, определённого для Vec<T>. Сам по себе этот код не делает ничего
полезного.
fn main() {
let v1 = vec![1, 2, 3];
let v1_iter = v1.iter();
}
Итератор хранится в переменной v1_iter. После создания
итератора его можно использовать различными способами. В листинге 3-5 мы перебирали
массив с помощью цикла for, чтобы выполнить некоторый код над каждым его элементом. Под
капотом это неявно создавало и затем потребляло итератор, но мы замалчивали
то, как именно это работает, до сих пор.
В примере из листинга 13-11 мы отделяем создание итератора от
использования итератора в цикле for. Когда цикл for вызывается с использованием
итератора в v1_iter, каждый элемент итератора используется в одной
итерации цикла, которая выводит каждое значение.
fn main() {
let v1 = vec![1, 2, 3];
let v1_iter = v1.iter();
for val in v1_iter {
println!("Got: {val}");
}
}
forВ языках, в которых нет итераторов, предоставляемых стандартной библиотекой, вы, скорее всего, написали бы ту же функциональность, начав переменную с индексом 0, используя эту переменную для индексации в вектор для получения значения и увеличивая значение переменной в цикле, пока она не достигнет общего числа элементов в векторе.
Итераторы выполняют всю эту логику за вас, сокращая повторяющийся код, в котором можно потенциально ошибиться. Итераторы дают больше гибкости для использования одной и той же логики со многими различными видами последовательностей, а не только со структурами данных, которые можно индексировать, как векторы. Давайте рассмотрим, как итераторы это делают.
Трейт Iterator и метод next
Все итераторы реализуют трейт с именем Iterator, который определён в
стандартной библиотеке. Определение трейта выглядит так:
#![allow(unused)]
fn main() {
pub trait Iterator {
type Item;
fn next(&mut self) -> Option<Self::Item>;
// методы с реализациями по умолчанию опущены
}
}
Обратите внимание, что это определение использует некоторый новый синтаксис: type Item и Self::Item,
которые определяют ассоциированный тип для этого трейта. Мы подробно поговорим об
ассоциированных типах в главе 20. Пока всё, что нужно знать, — это то, что этот код говорит, что реализация трейта Iterator
требует также определить
тип Item, и этот тип Item используется в возвращаемом типе метода next.
Другими словами, тип Item будет тем типом, который возвращается из
итератора.
Трейт Iterator требует от реализующих его типов определить только один метод: метод
next, который возвращает один элемент итератора за раз, обёрнутый в
Some, а когда итерация завершена, возвращает None.
Мы можем вызывать метод next у итераторов напрямую; листинг 13-12 демонстрирует,
какие значения возвращаются при повторных вызовах next у итератора, созданного
из вектора.
#[cfg(test)]
mod tests {
#[test]
fn iterator_demonstration() {
let v1 = vec![1, 2, 3];
let mut v1_iter = v1.iter();
assert_eq!(v1_iter.next(), Some(&1));
assert_eq!(v1_iter.next(), Some(&2));
assert_eq!(v1_iter.next(), Some(&3));
assert_eq!(v1_iter.next(), None);
}
}
next у итератораОбратите внимание, что нам нужно было сделать v1_iter изменяемым: вызов метода next у
итератора изменяет внутреннее состояние, которое итератор использует для отслеживания того, где
он находится в последовательности. Другими словами, этот код потребляет, или использует,
итератор. Каждый вызов next съедает элемент из итератора. Нам не нужно было
делать v1_iter изменяемым, когда мы использовали цикл for, потому что цикл
становился владельцем v1_iter и делал его изменяемым за кулисами.
Также обратите внимание, что значения, которые мы получаем от вызовов next, являются неизменяемыми
ссылками на значения в векторе. Метод iter создаёт итератор
по неизменяемым ссылкам. Если мы хотим создать итератор, который становится
владельцем v1 и возвращает значения с владением, мы можем вызвать into_iter вместо
iter. Аналогично, если мы хотим выполнять перебор по изменяемым ссылкам, мы можем вызвать
iter_mut вместо iter.
Методы, потребляющие итератор
Трейт Iterator имеет ряд различных методов с реализациями по умолчанию,
предоставляемыми стандартной библиотекой; вы можете узнать об этих
методах, посмотрев документацию стандартной библиотеки по API для трейта Iterator.
Некоторые из этих методов вызывают метод next в своих определениях, поэтому
при реализации трейта Iterator требуется реализовать метод next.
Методы, которые вызывают next, называются потребляющими адаптерами, потому что их вызов
расходует итератор. Один из примеров — метод sum, который становится владельцем
итератора и перебирает элементы, повторно вызывая next, тем самым
потребляя итератор. При переборе он добавляет каждый элемент к текущей
сумме и возвращает сумму, когда итерация завершена. В листинге 13-13 есть
тест, иллюстрирующий использование метода sum.
#[cfg(test)]
mod tests {
#[test]
fn iterator_sum() {
let v1 = vec![1, 2, 3];
let v1_iter = v1.iter();
let total: i32 = v1_iter.sum();
assert_eq!(total, 6);
}
}
sum для получения суммы всех элементов итератораНам не разрешено использовать v1_iter после вызова sum, потому что sum становится
владельцем итератора, у которого он вызван.
Методы, создающие другие итераторы
Адаптеры итераторов — это методы, определённые в трейте Iterator, которые не
потребляют итератор. Вместо этого они создают разные итераторы, изменяя
некоторый аспект исходного итератора.
Листинг 13-14 показывает пример вызова метода-адаптера итератора map,
который принимает замыкание для вызова на каждом элементе по мере перебора элементов.
Метод map возвращает новый итератор, который создаёт изменённые элементы. Замыкание
здесь создаёт новый итератор, в котором каждый элемент из вектора будет
увеличен на 1.
fn main() {
let v1: Vec<i32> = vec![1, 2, 3];
v1.iter().map(|x| x + 1);
}
map для создания нового итератораОднако этот код выдаёт предупреждение:
$ cargo run
Compiling iterators v0.1.0 (file:///projects/iterators)
warning: unused `Map` that must be used
--> src/main.rs:4:5
|
4 | v1.iter().map(|x| x + 1);
| ^^^^^^^^^^^^^^^^^^^^^^^^
|
= note: iterators are lazy and do nothing unless consumed
= note: `#[warn(unused_must_use)]` (part of `#[warn(unused)]`) on by default
help: use `let _ = ...` to ignore the resulting value
|
4 | let _ = v1.iter().map(|x| x + 1);
| +++++++
warning: `iterators` (bin "iterators") generated 1 warning
Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.47s
Running `target/debug/iterators`
Код в листинге 13-14 ничего не делает; замыкание, которое мы указали, никогда не вызывается. Предупреждение напоминает нам почему: адаптеры итераторов ленивы, и нам нужно потребить итератор здесь.
Чтобы исправить это предупреждение и потребить итератор, мы используем метод collect,
который мы использовали с env::args в листинге 12-1. Этот метод потребляет
итератор и собирает результирующие значения в тип коллекции.
В листинге 13-15 мы собираем результаты перебора итератора, который
возвращается из вызова map, в вектор. Этот вектор в конечном итоге будет
содержать каждый элемент из исходного вектора, увеличенный на 1.
fn main() {
let v1: Vec<i32> = vec![1, 2, 3];
let v2: Vec<_> = v1.iter().map(|x| x + 1).collect();
assert_eq!(v2, vec![2, 3, 4]);
}
map для создания нового итератора, а затем вызов метода collect для потребления нового итератора и создания вектораПоскольку map принимает замыкание, мы можем указать любую операцию, которую хотим выполнить
над каждым элементом. Это отличный пример того, как замыкания позволяют настраивать некоторое
поведение, повторно используя поведение перебора, которое предоставляет трейт
Iterator.
Можно связывать в цепочку несколько вызовов адаптеров итераторов для выполнения сложных действий читаемым способом. Но поскольку все итераторы ленивы, нужно вызвать один из методов потребляющих адаптеров, чтобы получить результаты от вызовов адаптеров итераторов.
Замыкания, захватывающие своё окружение
Многие адаптеры итераторов принимают замыкания в качестве аргументов, и часто замыкания, которые мы указываем в качестве аргументов адаптеров итераторов, будут замыканиями, захватывающими своё окружение.
Для этого примера мы используем метод filter, который принимает замыкание. Замыкание
получает элемент от итератора и возвращает bool. Если замыкание
возвращает true, значение будет включено в итератор, создаваемый
filter. Если замыкание возвращает false, значение не будет включено.
В листинге 13-16 мы используем filter с замыканием, которое захватывает переменную shoe_size
из своего окружения, чтобы перебрать коллекцию экземпляров
структуры Shoe. Он будет возвращать только обувь указанного размера.
#[derive(PartialEq, Debug)]
struct Shoe {
size: u32,
style: String,
}
fn shoes_in_size(shoes: Vec<Shoe>, shoe_size: u32) -> Vec<Shoe> {
shoes.into_iter().filter(|s| s.size == shoe_size).collect()
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn filters_by_size() {
let shoes = vec![
Shoe {
size: 10,
style: String::from("sneaker"),
},
Shoe {
size: 13,
style: String::from("sandal"),
},
Shoe {
size: 10,
style: String::from("boot"),
},
];
let in_my_size = shoes_in_size(shoes, 10);
assert_eq!(
in_my_size,
vec![
Shoe {
size: 10,
style: String::from("sneaker")
},
Shoe {
size: 10,
style: String::from("boot")
},
]
);
}
}
filter с замыканием, которое захватывает shoe_sizeФункция shoes_in_size становится владельцем вектора обуви и размера обуви
в качестве параметров. Она возвращает вектор, содержащий только обувь указанного
размера.
В теле shoes_in_size мы вызываем into_iter, чтобы создать итератор, который
становится владельцем вектора. Затем мы вызываем filter, чтобы адаптировать этот итератор
в новый итератор, который содержит только элементы, для которых замыкание возвращает
true.
Замыкание захватывает параметр shoe_size из окружения и
сравнивает значение с размером каждой обуви, сохраняя только обувь указанного
размера. Наконец, вызов collect собирает значения, возвращаемые
адаптированным итератором, в вектор, который возвращается функцией.
Тест показывает, что когда мы вызываем shoes_in_size, мы получаем обратно только обувь, которая
имеет тот же размер, что и указанное нами значение.