如果T是copy，你可以很容易地做到这一点：

let front: [T; 3] = my_array[..3].try_into().unwrap();

字符串
如果T不是Copy，但有一个便宜的Clone，你也可以这样做：

let front: [T; 3] = <&[T; 3]>::try_from(&my_array[..3]).unwrap().clone();

型
如果不是（克隆成本很高，或者T不是Clone），可以通过分配来实现：

let front = my_array.into_iter().take(3).collect::<Vec<T>>();
let front: [T; 3] = front.try_into().unwrap();

型
如果一个分配是不可接受的，但你每晚都在，你可以使用Iterator::next_chunk()：

#![feature(iter_next_chunk)]

let front: [T; 3] = my_array.into_iter().next_chunk().unwrap();

型
最后，如果没有什么对你来说是足够的，你可以使用不安全的代码（但这应该是最后的手段）：

use std::mem::ManuallyDrop;

pub fn front<T, const N: usize, const M: usize>(arr: [T; N]) -> [T; M] {
    assert!(M <= N);
    let mut arr = ManuallyDrop::new(arr);
    unsafe {
        let result: [T; M] = arr.as_ptr().cast::<[T; M]>().read();
        let rest = arr.as_mut_ptr().add(M);
        let rest_len = N - M;
        let rest = std::ptr::slice_from_raw_parts_mut(rest, rest_len);
        rest.drop_in_place();
        result
    }
}

型