Как получить срез (slice) в виде массива (array) фиксированного размера в Rust?

Использование TryInto из стандартной библиотеки

Самый идиоматичный и безопасный способ — использовать трейт TryFrom/TryInto, который доступен для конвертации среза в массив любого размера от 1 до 32 (в ночных версиях Rust — до 64). Этот метод требует проверки длины во время выполнения, что гарантирует безопасность.

use std::convert::TryInto;

fn main() {
    let data: Vec<u8> = vec![1, 2, 3, 4, 5];
    let slice: &[u8] = &data[0..4];
    
    // Пытаемся конвертировать срез в массив [u8; 4]
    let array: [u8; 4] = slice.try_into().expect("Срез должен содержать ровно 4 элемента");
    
    println!("{:?}", array); // [1, 2, 3, 4]
}

Если вы не уверены, что срез содержит ровно столько элементов, сколько нужно, можно обработать ошибку:

match slice.try_into() {
    Ok(array) => println!("Массив: {:?}", array),
    Err(_) => eprintln!("Ошибка: неверная длина среза"),
}

Почему это работает?

Трейт TryFrom<&[T]> реализован для массивов [T; N] где N от 1 до 32. Он копирует данные (поскольку массив владеет своими элементами) и проверяет, что длина среза равна N. Если длина не совпадает — возвращается ошибка.

Альтернатива: array_ref! из крейта arrayref

Если вам нужна производительность без копирования (получение ссылки на массив), можно использовать крейт arrayref. Он даёт ссылку на массив, не копируя данные:

use arrayref::array_ref;

fn main() {
    let data: Vec<u8> = vec![1, 2, 3, 4, 5];
    let slice: &[u8] = &data[0..4];
    
    // Получаем ссылку на массив &[u8; 4]
    let array_ref: &[u8; 4] = array_ref![slice, 0, 4];
    
    println!("{:?}", array_ref); // [1, 2, 3, 4]
}

Этот метод работает только для фиксированных константных сдвигов (0, 4) и паникует, если длина среза меньше 4. Он не копирует данные, что может быть критично для больших массивов.

Ручное копирование с помощью clone_from_slice

Если вам нужно именно владение массивом (не ссылка), можно использовать метод clone_from_slice:

fn main() {
    let data: Vec<u8> = vec![1, 2, 3, 4, 5];
    let slice: &[u8] = &data[0..4];
    
    let mut array: [u8; 4] = [0; 4];
    array.clone_from_slice(&slice[..4]); // копирует первые 4 элемента
    
    println!("{:?}", array); // [1, 2, 3, 4]
}

Этот метод паникует, если длина slice меньше 4. Если хотите избежать паники — сначала проверьте длину.

Рекомендация

• Для безопасного кода — используйте try_into() с обработкой ошибок.
• Для производительности без копирования — используйте arrayref (но осторожно с паникой).
• Для простых скриптов — можно использовать clone_from_slice или unwrap() на try_into().

Избегайте unsafe решений — в Rust есть все необходимые безопасные инструменты.

unsafe {
    let array: [u8; 4] = std::mem::transmute::<&[u8], &[u8; 4]>(slice).clone();
    // Или напрямую:
    let array: [u8; 4] = std::ptr::read(slice.as_ptr() as *const [u8; 4]);
}

macro_rules! array_from_slice {
    ($slice:expr, $n:expr) => {{
        let slice: &[u8] = $slice;
        let mut arr = [0u8; $n];
        arr.copy_from_slice(&slice[..$n]);
        arr
    }};
}

fn main() {
    let arr = array_from_slice!(&[1,2,3,4,5], 3);
    println!("{:?}", arr); // [1, 2, 3]
}