How do I concatenate two slices in Rust?

问题

I want to take the x first and last elements from a vector and concatenate them. I have the following code:

fn main() {
    let v = (0u64 .. 10).collect::<Vec<_>>();
    let l = v.len();
    vec![v.iter().take(3), v.iter().skip(l-3)];
}

This gives me the error

error[E0308]: mismatched types
 --> <anon>:4:28
  |
4 |     vec![v.iter().take(3), v.iter().skip(l-3)];
  |                            ^^^^^^^^^^^^^^^^^^ expected struct `std::iter::Take`, found struct `std::iter::Skip`
<anon>:4:5: 4:48 note: in this expansion of vec! (defined in <std macros>)
  |
  = note: expected type `std::iter::Take<std::slice::Iter<'_, u64>>`
  = note:    found type `std::iter::Skip<std::slice::Iter<'_, u64>>`

How do I get my vec of 1, 2, 3, 8, 9, 10? I am using Rust 1.12.

回答1:

You should collect() the results of the take() and extend() them with the collect()ed results of skip():

let mut p1 = v.iter().take(3).collect::<Vec<_>>();
let p2 = v.iter().skip(l-3);

p1.extend(p2);

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

Edit: as Neikos said, you don't even need to collect the result of skip(), since extend() accepts arguments implementing IntoIterator (which Skip does, as it is an Iterator).

Edit 2: your numbers are a bit off, though; in order to get 1, 2, 3, 8, 9, 10 you should declare v as follows:

let v = (1u64 .. 11).collect::<Vec<_>>();

Since the Range is left-closed and right-open.

回答2:

Just use .concat() on a slice of slices:

fn main() {
    let v = (0u64 .. 10).collect::<Vec<_>>();
    let l = v.len();
    let first_and_last = [&v[..3], &v[l - 3..]].concat();
    println!("{:?}", first_and_last);
    // The output is `[0, 1, 2, 7, 8, 9]`
}

This creates a new vector, and it works with arbitrary number of slices.

(Playground link)

回答3:

Ok, first of all, your initial sequence definition is wrong. You say you want 1, 2, 3, 8, 9, 10 as output, so it should look like:

    let v = (1u64 .. 11).collect::<Vec<_>>();

Next, you say you want to concatenate slices, so let's actually use slices:

    let head = &v[..3];
    let tail = &v[l-3..];

At this point, it's really down to which approach you like the most. You can turn those slices into iterators, chain, then collect...

    let v2: Vec<_> = head.iter().chain(tail.iter()).collect();

...or make a vec and extend it with the slices directly...

    let mut v3 = vec![];
    v3.extend_from_slice(head);
    v3.extend_from_slice(tail);

...or extend using more general iterators (which will become equivalent in the future with specialisation, but I don't believe it's as efficient just yet)...

    let mut v4: Vec<u64> = vec![];
    v4.extend(head);
    v4.extend(tail);

...or you could use Vec::with_capacity and push in a loop, or do the chained iterator thing, but using extend... but I have to stop at some point.

Full example code:

fn main() {
    let v = (1u64 .. 11).collect::<Vec<_>>();
    let l = v.len();

    let head = &v[..3];
    let tail = &v[l-3..];

    println!("head: {:?}", head);
    println!("tail: {:?}", tail);

    let v2: Vec<_> = head.iter().chain(tail.iter()).collect();
    println!("v2: {:?}", v2);

    let mut v3 = vec![];
    v3.extend_from_slice(head);
    v3.extend_from_slice(tail);
    println!("v3: {:?}", v3);

    // Explicit type to help inference.
    let mut v4: Vec<u64> = vec![];
    v4.extend(head);
    v4.extend(tail);
    println!("v4: {:?}", v4);
}

来源：https://stackoverflow.com/questions/40154150/how-do-i-concatenate-two-slices-in-rust

标签

rust