Итерация по диапазону с нестандартным шагом в Rust: 3 способа

Онлайн-тренажер Python для начинающих

Изучайте Python легко и без перегрузки теорией. Решайте практические задачи с автоматической проверкой, получайте подсказки на русском языке и пишите код прямо в браузере — без необходимости что-либо устанавливать.

Начать курс

Как в Rust пройтись по числам с шагом 3, 5 или 100? Полный разбор

Представьте: вы пишете на Rust и вам нужно вывести все чётные числа от 0 до 20. Или, скажем, построить последовательность 0, 5, 10, 15, 20. В Python вы бы просто написали range(0, 21, 5) — и готово. А как быть в Rust? Тут есть нюансы, и сегодня мы их разберём.

Этот вопрос — один из самых популярных на Stack Overflow (тысячи просмотров). И неудивительно: стандартный for i in 0..10 работает только с шагом 1. А если нужен другой шаг? Оказывается, есть целых три способа, и каждый — со своими плюсами и подводными камнями.

Мы не просто покажем код — мы сравним подходы по производительности, читаемости и гибкости. Поехали!

Почему в Rust нет встроенного range с шагом?

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

Длинный ответ: в экосистеме Rust философия «явное лучше неявного». Вместо того чтобы засовывать шаг в синтаксис диапазона, создатели предложили гибкие инструменты адаптации итераторов. И это открывает больше возможностей, чем кажется.

Способ 1: `step_by()` — самый прямой путь

В стандартной библиотеке Rust есть метод step_by(n), который создаёт итератор, пропускающий каждые n-1 элементов. Вот как он работает:

fn main() {
    // Выводим числа от 0 до 20 с шагом 5
    for i in (0..=20).step_by(5) {
        println!("{}", i);
    }
    // Вывод: 0, 5, 10, 15, 20
}

Обратите внимание: я использовал 0..=20 (включительно), а не 0..20 (исключительно). Если нужен шаг 3 до 10, пишем (0..10).step_by(3) — получим 0, 3, 6, 9.

Плюсы step_by():

Простота — одна строка, никаких замыканий
Читаемость — сразу видно, что делаем
Производительность — минимальные накладные расходы

Минусы:

Работает только с целыми числами (i32, u64 и т.д.)
Нельзя задать динамический шаг на каждой итерации
Появился только в Rust 1.28 (но это уже давно)

Этот метод — идеальный выбор для 90% задач. Если вам нужно просто пройтись по числам с постоянным шагом — используйте step_by().

Способ 2: `filter()` — когда шаг — это условие

А что, если шаг не постоянный? Например, нужно вывести числа, которые делятся на 3 без остатка. Или числа, где сумма цифр больше 5. Тут на помощь приходит filter():

fn main() {
    // Все числа от 0 до 30, кратные 4
    for i in (0..=30).filter(|x| x % 4 == 0) {
        println!("{}", i);
    }
    // Вывод: 0, 4, 8, 12, 16, 20, 24, 28

    // А теперь — числа, которые не делятся на 3
    for i in (0..20).filter(|x| x % 3 != 0) {
        println!("{}", i);
    }
    // Вывод: 1, 2, 4, 5, 7, 8, 10, 11, 13, 14, 16, 17, 19
}

Здесь мы передаём замыкание (closure), которое проверяет каждое число. filter() оставляет только те элементы, для которых условие истинно.

Когда filter() лучше step_by():

Шаг зависит от значения (например, «все простые числа»)
Нужно комбинировать с другими условиями
Шаг не постоянный (например, числа Фибоначчи)

Недостатки:

Чуть медленнее, чем step_by() — приходится проверять каждое число
Код может быть менее очевидным для новичков

Лично я использую filter(), когда нужно не просто «каждый n-ый», а «каждый, кто соответствует правилу». Это мощнее, но требует больше внимания к логике.

Способ 3: `.map()` + арифметика — для математиков

Третий подход — генерировать числа с помощью .map() и формулы. Например, чтобы получить последовательность 1, 4, 9, 16 (квадраты чисел):

fn main() {
    // Квадраты чисел от 1 до 5
    for i in (1..=5).map(|x| x * x) {
        println!("{}", i);
    }
    // Вывод: 1, 4, 9, 16, 25

    // Арифметическая прогрессия с шагом 7: 0, 7, 14, 21...
    for i in (0..4).map(|x| x * 7) {
        println!("{}", i);
    }
    // Вывод: 0, 7, 14, 21
}

Здесь мы берём диапазон 0..4 (0, 1, 2, 3) и умножаем каждое число на 7. Получаем 0, 7, 14, 21. Можно делать и более сложные преобразования.