Iterating over Vec with Index in Rust: 4 Ways Compared

Online Python Trainer for Beginners

Learn Python easily without overwhelming theory. Solve practical tasks with automatic checking, get hints in Russian, and write code directly in your browser — no installation required.

Start Course

Iterating over Vec with Index in Rust: From Beginner to Pro

Imagine: you're writing in Rust and need to go through the elements of a vector, but you need to know not only the value but also its position. It seems like a simple task, but it often stumps beginners. Where is the for i in range(len(vec)), like in Python? What if I want to change elements? And which is faster?

In this article, we'll break down all popular ways to iterate over Vec with an index in Rust, comparing their performance, readability, and safety. You'll learn which method to choose in 2024 and why enumerate isn't always a silver bullet.

Why is this important?

Rust doesn't have a classic for i in 0..vec.len() as the only correct path. The language offers several paradigms: from functional iterators to low-level loops. Understanding the difference between them is key to writing efficient and idiomatic code. This is especially critical when working with vectors, where an index may be needed to modify neighboring elements or track a position in an algorithm.

Method 1: The Classic — `enumerate`

The most common and recommended method. The enumerate method wraps an iterator, adding its index to each element:

let vec = vec!["a", "b", "c", "d"];for (index, value) in vec.iter().enumerate() {    println!("Position {}: {}", index, value);}

Pros:

Idiomatic and readable
Safe — no risk of going out of bounds
Works with any iterator, not just Vec

Cons: Cannot directly modify vector elements (requires iter_mut()).

Method 2: By Index — `0..vec.len()`

An approach familiar to everyone from C++ or Python. Use a range of indices:

let mut vec = vec![10, 20, 30, 40];for i in 0..vec.len() {    vec[i] += i; // modify element by index    println!("vec[{}] = {}", i, vec[i]);}

Pros:

Full control over the index and element
Can modify elements via vec[i]
Intuitively understandable for beginners

Cons: Slower than iterators (additional bounds checking). The Rust community considers it "non-idiomatic".

Method 3: `while` with a Counter

The most "manual" method, which you'll encounter in old code or during optimization:

let vec = vec![1.0, 2.0, 3.0];let mut i = 0;while i < vec.len() {    println!("Element {}: {}", i, vec[i]);    i += 1;}

Pros: Maximum flexibility (can jump by indices, change step).

Cons: Easy to make a mistake with the condition. Not recommended without a good reason.

Method 4: `zip` with a Range

A functional approach when you need to iterate over two vectors in parallel with indices:

let names = vec!["Alice", "Bob", "Charlie"];let scores = vec![95, 87, 92];

for (i, (name, score)) in (0..).zip(names.iter()).zip(scores.iter()) {    println!("{}: {} scored {} points", i, name, score);}

Pros: Powerful for parallel iteration. The infinite range 0.. is automatically truncated.

Cons: Can be hard to read. Overkill for simple tasks.