Collections को Iterate करना

Iterating का मतलब है किसी list में हर item को देखने या उपयोग करने के लिए एक-एक करके visit करना।

In this page:

Iterating by Reference with iter
Mutating in Place with iter_mut
Taking Ownership with into_iter
Chaining Iterator Adapters

Syntax

rust

for item in &collection {}       // borrow
for item in &mut collection {}   // mutably borrow
for item in collection {}        // consume
for (i, item) in collection.iter().enumerate() {}

Iterating by Reference with iter

.iter() हर element के references का एक iterator produce करता है, original collection को untouched और बाद में अब भी usable छोड़ते हुए।

उदाहरण: Iterating by Reference with iter

markup

// Entry point: execution of the program starts here
fn main() {
    // Declare an immutable variable `numbers`, set to `vec![1, 2, 3]`
    let numbers = vec![1, 2, 3];
    // Loop over `numbers.iter()`, binding each item to `n`
    for n in numbers.iter() {
        // Print "Value: {}" to the console, substituting in `n` (with a trailing newline)
        println!("Value: {}", n);
    }
    // Print "Still usable: {:?}" to the console, substituting in `numbers` (with a trailing newline)
    println!("Still usable: {:?}", numbers);
}

Mutating in Place with iter_mut

.iter_mut() हर element के mutable references produce करता है, आपको iteration के दौरान collection की contents सीधे modify करने देते हुए।

उदाहरण: Mutating in Place with iter_mut

markup

// Entry point: execution of the program starts here
fn main() {
    // Declare a mutable variable `numbers`, initialized to `vec![1, 2, 3]`
    let mut numbers = vec![1, 2, 3];
    // Loop over `numbers.iter_mut()`, binding each item to `n`
    for n in numbers.iter_mut() {
        *n *= 10;
    }
    // Print "{:?}" to the console, substituting in `numbers` (with a trailing newline)
    println!("{:?}", numbers);
}

Taking Ownership with into_iter

किसी collection को value से iterate करना (into_iter() के साथ, या एक plain for x in collection) collection को consume करता है, हर element को एक समय में एक बाहर move करते हुए।

उदाहरण: Taking Ownership with into_iter

markup

// Entry point: execution of the program starts here
fn main() {
    // Declare an immutable variable `words`, set to `vec![String::from("a"), String::from("b")]`
    let words = vec![String::from("a"), String::from("b")];
    // Loop over `words.into_iter()`, binding each item to `word`
    for word in words.into_iter() {
        // Print "Owned word: {}" to the console, substituting in `word` (with a trailing newline)
        println!("Owned word: {}", word);
    }
}

Chaining Iterator Adapters

.map() और .filter() जैसे iterator methods को आखिर में results को collect या sum करने से पहले declaratively elements transform और select करने के लिए एक साथ chain किया जा सकता है।

उदाहरण: Chaining Iterator Adapters

markup

// Entry point: execution of the program starts here
fn main() {
    // Declare an immutable variable `numbers`, set to `vec![1, 2, 3, 4, 5]`
    let numbers = vec![1, 2, 3, 4, 5];
    // Declare an immutable variable `sum_of_squares` (an integer), set to `numbers.iter().map(|n| n * n).filter(|n| n % 2 == 0).sum()`
    let sum_of_squares: i32 = numbers.iter().map(|n| n * n).filter(|n| n % 2 == 0).sum();
    // Print "Sum of even squares: {}" to the console, substituting in `sum_of_squares` (with a trailing newline)
    println!("Sum of even squares: {}", sum_of_squares);
}

Chapter Quiz — Complete all 6 topics to unlock

0/6 topics done

Complete these topics first:

← Previous Lesson The Entry API Next Lesson → Sorting Collections

Collections को Iterate करना

Iterating by Reference with iter

Mutating in Place with iter_mut

Taking Ownership with into_iter

Chaining Iterator Adapters

Chapter Quiz — Complete all 6 topics to unlock

Login to run this code