Rust: `iter` vs `into_iter`

In Rust, understanding the difference between `iter` and `into_iter` is crucial for efficient and correct iteration over collections like vectors, arrays, or other data structures. Both methods are used to create iterators, but they serve different purposes based on how you intend to iterate over your data.

`iter`: Borrowing the Collection

– Creates a Reference Iterator: When you call `iter()` on a collection, it returns an iterator that yields references to the items in the collection. This means that the collection is not moved, and you can continue to use it after the iteration.

– Common Use Case: Use `iter()` when you want to iterate over the elements without taking ownership, allowing the original collection to remain unchanged.

Example:

let v = vec![1, 2, 3];

for val in v.iter() {

    println!("{}", val);

}

// v is still usable here because it was not consumed

`into_iter`: Taking Ownership

– Consumes the Collection: Calling `into_iter()` on a collection transforms it into an iterator that yields items by value. This method consumes the collection, meaning you can’t use it afterward because its ownership is transferred to the iterator.

– Common Use Case: Use `into_iter()` when you want to take ownership of the items, such as when you need to modify, move, or consume them.

Example:

let v = vec![1, 2, 3];

for val in v.into_iter() {

    println!("{}", val);

}

// v cannot be used here because it was consumed

Key Differences

– Ownership: `iter()` borrows the collection, keeping the original intact, while `into_iter()` takes ownership and consumes the collection.

– Use Cases: Use `iter()` for read-only operations and `into_iter()` when you need to take ownership and potentially mutate or consume the data.

Understanding when to use `iter` versus `into_iter` is essential for writing idiomatic and efficient Rust code, as it directly impacts how you handle ownership, borrowing, and memory management in your programs.