是否可以将使用 `.map()` 的函数应用于 Rust 中嵌套向量的每个元素？

Question

是否可以将闭包或函数应用于

Vec<Vec<T>>

的每个元素？

这可以用

.map()

来完成吗？如果没有的话，还有其他选择吗？

我想将

Vec<Vec<Option<f64>>>

转换为

Vec<Vec<f64>>

。我对如何做到这一点的第一个想法是使用

.map()

加上闭包。

当我尝试这样做时，我发现

.iter().map(f)

不是正确的方法，因为这将

f

应用于第一个

Vec

的每个元素，而这些元素本身就是

Vec

。

我还研究了

iter().flatten()

，但这会产生一个

Vec<T>

，其中包含

Vec<Vec<T>>

中的所有元素，它“破坏”了我需要保留的二维结构。

我猜一种可能的方法是使

f

的闭包逻辑本身称为

iter().map(g)

，其中

g

从

Option<f64> -> f64

进行所需的转换。但这可能有点不优雅。

Answer 1

是的，这是可能的：

fn main() {
    let vec = vec![vec![Some(1.), None, Some(2.)]];

    let vec2 = vec.iter().map(|inner_vec| {
        inner_vec.iter().map(|option| {
            option.unwrap_or(0.)
        }).collect::<Vec<_>>()
    }).collect::<Vec<_>>();

    println!("vec2: {:?}", vec2);
}

// Program output:
// vec2: [[1.0, 0.0, 2.0]]

基本上，您可以迭代最外面的 Vec 并映射其元素。这些元素是内部向量，您可以（再次）迭代并映射其元素。然后，您可以对内部

Option<f64>

应用一些操作，例如

.unwrap_or(0.)

，然后再次将两层嵌套重新收集回 Vecs 中。