How to Iterate a Vec with Its Index in Rust

By the end of this page, you will understand how to iterate over a Vec<T> in Rust while also getting each element's index. You will learn to use .enumerate(), see how it works with .iter(), .iter_mut(), and .into_iter(), and understand common mistakes beginners make when working with indexed iteration.

In Rust, iterating over a collection and also tracking the position of each item is a very common task. The standard way to do this is with the .enumerate() adapter.

enumerate() takes any iterator and transforms it into a new iterator that yields pairs:

• the current index
• the current item

For a Vec<T>, you usually start with one of these iterator methods:

• .iter() gives immutable references like &T
• .iter_mut() gives mutable references like &mut T
• .into_iter() gives owned values like T

Then you add .enumerate() to include the index.

Example:

let v = vec![10, 20, 30];
for (index, value) in v.iter().enumerate() {
    println!(, index, value);
}

Think of .iter() as a person handing you each item from a row of boxes.

Normally, you only get the item:

• box content: 10
• box content: 20
• box content: 30

When you add .enumerate(), that person also tells you which box number it came from:

• box 0: 10
• box 1: 20
• box 2: 30

So enumerate() is like attaching a label number to every item as it comes through the iterator.

It does not change the vector itself. It just changes what the iterator produces.

The most common syntax is:

for (index, item) in vec.iter().enumerate() {
    // use index and item
}

Basic example

fn main() {
    let v = vec![1, 2, 3];

    for (pos, e) in v.iter().enumerate() {
        println!("position: {}, value: {}", pos, e);
    }
}

Output:

position: 0, value: 1
position: 1, value: 2
position: 2, value: 3

Here:

• v.iter() produces &i32
• .enumerate() turns that into (usize, &i32)
• pos is the index
• e is a reference to the element

Consider this example:

fn main() {
    let v = vec![5, 6, 7];

    for (pos, e) in v.iter().enumerate() {
        println!("pos = {}, e = {}", pos, e);
    }
}

Let’s trace it.

Step 1: Create the vector

let v = vec![5, 6, 7];

v is a Vec<i32> containing three elements.

Step 2: Call iter()

v.iter()

This creates an iterator over references:

• &5
• &6

Indexed iteration appears in many practical Rust programs.

Display numbered results

let tasks = vec!["build", "test", "deploy"];
for (i, task) in tasks.iter().enumerate() {
    println!("{}. {}", i + 1, task);
}

Useful for:

• CLI menus
• todo lists
• ranked output

Validate imported rows

let rows = vec!["Alice", "", "Charlie"];
for (i, row) in rows.iter().enumerate() {
    if row.is_empty() {
        println!("Row {} is empty", i);
    }
}

Useful for:

• CSV import tools
• parsers
• batch processing scripts

Update elements based on position

In real Rust codebases, developers often combine enumerate() with other iterator tools instead of writing manual counters.

Common pattern: immutable read with index

for (i, item) in items.iter().enumerate() {
    println!("{}: {:?}", i, item);
}

Used for reporting, debugging, and rendering.

Common pattern: mutate each element with its index

for (i, item) in items.iter_mut().enumerate() {
    *item += i as i32;
}

Used in data transformation and preprocessing.

Common pattern: skip or filter while keeping original positions

for (i, item) in items.iter().enumerate() {
    if item.is_empty() {
        continue;
    }
    println!("{} => {}", i, item);
}

This is useful when indexes matter for error messages or traceability.

1. Forgetting to call enumerate()

Broken code:

fn main() {
    let v = vec![1, 2, 3];

    for (pos, e) in v.iter() {
        println!("{} {}", pos, e);
    }
}

Why it fails:

• v.iter() yields only one thing each time: &i32
• the loop expects a pair like (pos, e)

Fix:

for (pos, e) in v.iter().enumerate() {
    println!("{} {}", pos, e);
}

2. Confusing references with values

With .iter(), the item is a reference.

let  = [, , ];
 (i, value)  v.().() {
    (, i, value);
}

Indexed iteration in Rust

Read-only iteration

for (i, item) in v.iter().enumerate() {
    println!("{} -> {}", i, item);
}

• i is usize
• item is &T

Mutable iteration

for (i, item) in v.iter_mut().enumerate() {
    *item = i as i32;
}

• item is &mut T
• use *item to modify the value

Owning iteration

for (i, item) in v.into_iter().enumerate() {
    (, i, item);
}

How do I get the index while iterating over a vector in Rust?

Use .enumerate() after creating an iterator:

for (i, item) in v.iter().enumerate() {
    // ...
}

Does enumerate() work only with Vec?

No. It works with any iterator, including iterators from slices, arrays, strings, and custom iterator types.

Why is the index type usize?

Because indexes in Rust collections use usize, which is the platform-sized unsigned integer type used for memory indexing.

What is the difference between iter() and into_iter() with enumerate()?

• iter() gives references like &T
• into_iter() gives owned values like T and consumes the collection

Can I start counting from 1 instead of 0?

• Iterators — enumerate() is an iterator adapter, so understanding iterators is the foundation.
• Borrowing — .iter() and .iter_mut() return references, which is directly related to Rust borrowing rules.
• Ownership — .into_iter() consumes the vector, so ownership affects how you iterate.
• Pattern matching — for (i, item) in ... destructures tuple values using pattern matching.
• Slices — vectors often expose slices, and slice iteration works the same way.
• for loops — enumerate() is commonly used inside for loops for readable iteration.
• Mutable references — needed when using .iter_mut() to change values in place.
• Collections in Rust — Vec<T> is one of Rust’s main collections, and indexed iteration is a common operation.