深入理解 Rust 中的闭包和迭代器

在 Rust 中，闭包（closures）和迭代器（iterators）是两个非常重要的概念，它们在函数式编程和并发编程中起到了关键作用。本文将通过详细的示例和单元测试，帮助初学者深入理解这两个概念。

闭包（Closures）

闭包是可以捕获其环境的匿名函数。它们能够访问定义时的作用域中的变量，并在执行时使用这些变量。闭包的语法类似于函数，但更加简洁。

示例 1：基础闭包

我们首先来看一个简单的闭包示例，它计算两个数的和。

fn main() {
    let add = |a: i32, b: i32| -> i32 {
        a + b
    };

    let sum = add(5, 10);
    println!("Sum: {}", sum);
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_add_closure() {
        let add = |a: i32, b: i32| -> i32 {
            a + b
        };
        assert_eq!(add(5, 10), 15);
    }
}

在这个例子中，我们定义了一个闭包 add 来计算两个数的和，并通过单元测试验证其正确性。

示例 2：捕获环境变量的闭包

闭包可以捕获其定义时的环境变量，这使得它们非常强大和灵活。

fn main() {
    let factor = 2;

    let multiply = |a: i32| -> i32 {
        a * factor
    };

    let result = multiply(5);
    println!("Result: {}", result);
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_multiply_closure() {
        let factor = 2;
        let multiply = |a: i32| -> i32 {
            a * factor
        };
        assert_eq!(multiply(5), 10);
    }
}

在这个例子中，闭包 multiply 捕获了外部变量 factor，并在其计算过程中使用。

迭代器（Iterators）

迭代器是一个实现了 Iterator trait 的对象，Iterator trait 定义了一个方法 next，该方法返回迭代器中的下一个元素。迭代器是惰性计算的，只有在使用时才会生成元素。

示例 1：基础迭代器

我们首先来看一个手动迭代集合的示例。

fn main() {
    let numbers = vec![1, 2, 3, 4, 5];
    let mut iter = numbers.iter();

    while let Some(x) = iter.next() {
        println!("{}", x);
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_iter() {
        let numbers = vec![1, 2, 3, 4, 5];
        let mut iter = numbers.iter();
        assert_eq!(iter.next(), Some(&1));
        assert_eq!(iter.next(), Some(&2));
        assert_eq!(iter.next(), Some(&3));
        assert_eq!(iter.next(), Some(&4));
        assert_eq!(iter.next(), Some(&5));
        assert_eq!(iter.next(), None);
    }
}

在这个例子中，我们手动调用 next 方法来获取迭代器的每一个元素，并通过单元测试验证其行为。

示例 2：使用 `map` 和 `filter` 适配器

map 和 filter 是常见的迭代器适配器，用于对集合中的元素进行转换和筛选。

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

    let doubled: Vec<i32> = numbers.iter().map(|x| x * 2).collect();
    println!("{:?}", doubled); // 输出 [2, 4, 6, 8, 10]

    let even_numbers: Vec<i32> = numbers.iter().filter(|&&x| x % 2 == 0).collect();
    println!("{:?}", even_numbers); // 输出 [2, 4]
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_map() {
        let numbers = vec![1, 2, 3, 4, 5];
        let doubled: Vec<i32> = numbers.iter().map(|x| x * 2).collect();
        assert_eq!(doubled, vec![2, 4, 6, 8, 10]);
    }

    #[test]
    fn test_filter() {
        let numbers = vec![1, 2, 3, 4, 5];
        let even_numbers: Vec<i32> = numbers.iter().filter(|&&x| x % 2 == 0).collect();
        assert_eq!(even_numbers, vec![2, 4]);
    }
}

在这个例子中，我们使用 map 对每个元素进行转换，并使用 filter 对元素进行筛选。通过单元测试，验证 map 和 filter 的正确性。

示例 3：组合迭代器适配器

可以将多个迭代器适配器组合使用，以实现更复杂的数据处理。

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

    let result: Vec<i32> = numbers.iter()
                                  .filter(|&&x| x % 2 != 0) // 筛选奇数
                                  .map(|&x| x * 2)          // 将其乘以 2
                                  .collect();

    println!("{:?}", result); // 输出 [2, 6, 10]
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_combined_iter() {
        let numbers = vec![1, 2, 3, 4, 5];
        let result: Vec<i32> = numbers.iter()
                                      .filter(|&&x| x % 2 != 0)
                                      .map(|&x| x * 2)
                                      .collect();
        assert_eq!(result, vec![2, 6, 10]);
    }
}

在这个例子中，我们首先用 filter 筛选出所有奇数，然后用 map 将这些奇数乘以 2，最后通过 collect 将结果收集成一个向量。通过单元测试，验证组合迭代器的正确性。

总结

闭包：是可以捕获其环境的匿名函数，能够简化代码并提供更强的灵活性。
迭代器：是实现了 Iterator trait 的对象，用于惰性地遍历集合并对数据进行转换和筛选。

通过这些详细的示例和单元测试，希望能够帮助初学者更好地理解 Rust 中的闭包和迭代器。