如何将其他元素推向Vec＆lt;＆amp; vec＆lt; gt;＆gt;？

Question

我正在尝试完成一些简单的事情，但不确定如何在Rust中做到这一点。

我有一个vec＆lt;＆amp; vec＆gt;，类似于以下示例。

[
 ["a1", "b2", "c3"],
 ["d1", "e2", "f3"],
 ["g1", "h2", "i3"]
]

我想在每个向量的末尾推一个字符串。

[
 ["a1", "b2", "c3", "something"],
 ["d1", "e2", "f3", "something"],
 ["g1", "h2", "i3", "something"]
]

到目前为止，我尝试过的是：

vec_of_strings
    .iter_mut()
    .map(|x| x.clone().push("something".to_string()))
    .collect::<Vec<_>>();

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

但是输出表明什么都没有附加。

Answer 1

您正在做的是创建新的 vec ，它不会修改存在的。实际上，当您不成熟时，现有的商品无法修改（＆amp; in vec＆lt;＆amp;＆amp;＆amp; vec＆lt; _ _＆gt;＆gt; ）。

请注意，使用 .iter_mut（）而不是 .Iter（）在这里毫无意义，因为您没有突变元素。

此外， vec :: push（）不返回任何内容，因此 .to_string（） Invocation应该给您编译时错误。 （我假设您是要在字符串文字上调用它。）

解决上述问题：

let new_vec_of_strings = vec_of_strings
  .iter()
  .map(|x| {
    let mut x = x.clone();
    x.push("something".to_string());
    x
  })
  .collect::<Vec<_>>();

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

但是，这一切似乎都像 xy问题< /a> - 可能有一种更好的方法来实现您的目标。

Answer 2

如果我正确理解，则需要在 MAP 中返回 vec 。

fn main() {
    let mut vec_of_strings = vec![
        vec!["a1", "b2", "c3"], 
        vec!["d1", "e2", "f3"], 
        vec!["g1", "h2", "i3"]
    ];
    println!("{:?}", vec_of_strings);
    
    let vec_of_strings: Vec<Vec<&str>> = vec_of_strings.iter_mut().map(|x| {x.push("something"); x.clone()}).collect();
    println!("{:?}", vec_of_strings);
}

Answer 3

我认为对地图方法的方法有误解。该方法通常用于原始值保持不变的数据转换。您在这里真正做的是造成副作用， MAP 方法在这里根本没有帮助您。

只需使用循环的即可。这并不是说您使用地图和插入器保存击键。

但是，您提到您有一个 vec＆lt;＆amp; vec＆gt; 。拥有这种类型似乎不适合您的目的。克隆整个vec只是为了添加1个元素，对于性能是可怕的。

我看到了2个选择：要么拥有完全拥有，即 vec＆lt; vec＆gt; ，要么只是使Inner vec sable可变，如 vec＆amp; mut中vec＆gt; 。

这是第一个选项，我认为这是最惯用的：

fn main() {
    let mut vec_of_strings = vec![
        vec!["a1", "b2", "c3"], 
        vec!["d1", "e2", "f3"], 
        vec!["g1", "h2", "i3"]
    ];
 
    for vec in vec_of_strings.iter_mut() {
        vec.push("something");
    }
    
    println!("{vec_of_strings:?}");
}

如果以拥有形式的形式不可接受，那么另一种选择是使用 vec＆＆amp＆amp; mut vec vec＆gt; ：

fn main() {
    fn main() {
    let mut vec_of_strings = vec![
        vec!["a1", "b2", "c3"], 
        vec!["d1", "e2", "f3"], 
        vec!["g1", "h2", "i3"]
    ];
    
    //suppose somehow a function gave you this:
    let vec_of_mut_strings: Vec<&mut Vec<_>> = vec_of_strings
        .iter_mut()
        .collect();
    
    for vec in vec_of_mut_strings {
        vec.push("something");
    }
    
    //notice that the original vec_of_strings change
    println!("{vec_of_strings:?}");
}
}

Answer 4

我假设您的输出看起来像这样：

[(), (), ()]

以下是一些建议：

• 更喜欢使用 for_each 用于突变而不是地图：

    vec_o​​f_strings
      .ITER_MUT（）
      .for_each（| x | {
          X.Push（“某物”）;
      }）;
  
  println！（“ {：？}”，vec_o​​f_strings）;
   

  请注意，这是假定 vec_o​​f_strings 的定义类似：

   让mut vec1 = vec！[“ a1”，“ b2”，“ c3”];
  令mut vec2 = vec！[“ d1”，“ e2”，“ f3”];
  令mut vec3 = vec！[“ g1”，“ h2”，“ i3”];
  令mut vec_o​​f_strings：vec＆lt;＆amp; mut vec＆lt; = vec！[＆amp; mut Vec1，＆amp; mut Vec2，＆amp; mut Vec3];
   

  
  

• Playgroung 't返回任何东西，因为 vec :: push 不返回向量。

  独立 x 到另一行以返回向量。

    vec_o​​f_strings.iter_mut（）
      .map（| x | {
          X.Push（“某物”）;
          x
      }））
      。
   

  请注意，这是假定 vec_o​​f_strings 的定义类似：

   让mut vec1 = vec！[“ a1”，“ b2”，“ c3”];
  令mut vec2 = vec！[“ d1”，“ e2”，“ f3”];
  令mut vec3 = vec！[“ g1”，“ h2”，“ i3”];
  令mut vec_o​​f_strings：vec＆lt;＆amp; mut vec＆lt; = vec！[＆amp; mut Vec1，＆amp; mut Vec2，＆amp; mut Vec3];
   

  
  

• 您在使用矢量元素的类型（＆amp; str ）时可能更明确>地图：

    .collect ::＆lt; vec＆lt;＆amp;＆amp; str＆gt;＆gt;（）;
   

  而不是

    .collect ::＆lt; vec＆lt; _＆gt;＆gt;（）;
   

  是由编译器推断为 vec＆lt;（）＆gt; ，因为 vec的返回类型因此，输出）。

  


Answer 5

一种解决原始格式将每个数组延伸到一个条目的解决方案：

vec_of_strings
    .iter_mut()
    .map(|a| {
        let mut v = a.to_vec();
        v.push("something");
        let arr: [&str; 4] = v.try_into().unwrap();
        arr
    })
    .collect::<Vec<[&str; 4]>>();

游乐场