Primitive Type array

1.0.0 ·

Expand description

一个固定大小的数组，表示为 [T; N]，用于元素类型 T 和非负编译时常量大小 N。

创建数组有两种语法形式：

包含每个元素的列表，即 [x, y, z]。
重复表达式 [expr; N]，其中 N 是在数组中重复 expr 的次数。expr 必须是:
- 实现 Copy trait 的类型的值
- const 值

请注意，[expr; 0] 是允许的，并产生一个空数组。然而，这仍然会计算 expr，并立即丢弃结果值，因此请注意副作用。

如果元素类型允许，则任何大小的数组都将实现以下 traits：

Copy
Clone
Debug
IntoIterator (为 [T; N]、&[T; N] 和 &mut [T; N] 实现)
PartialEq, PartialOrd, Eq, Ord
Hash
AsRef, AsMut
Borrow, BorrowMut

如果元素类型允许，则大小为 0 到 32 (inclusive) 的数组将实现 Default trait。作为权宜之计，trait 实现是静态生成的，最大大小为 32。

大小从 1 到 12 (inclusive) 的数组实现 From<Tuple>，其中 Tuple 是适当长度的同质 tuple。

数组强制转换为 slices ([T]) ，因此可以在数组上调用 slice 方法。实际上，这提供了用于处理数组的大多数 API。

切片具有动态大小，并且不强制转换为数组。而是使用 slice.try_into().unwrap() 或 <ArrayType>::try_from(slice).unwrap()。

如果输入切片长度与结果数组长度相同，则数组的 try_from(slice) 实现 (以及相应的 slice.try_into() 数组实现) 成功。

当优化器可以轻松确定切片长度时，它们优化得特别好，例如 <[u8; 4]>::try_from(&slice[4..8]).unwrap(). Array 实现 TryFrom 返回:

[T; N] 从切片的元素复制
&[T; N] 引用原始切片的元素
&mut [T; N] 引用原始切片的元素

您可以使用切片模式将元素移出数组。如果需要一个元素，请参见 mem::replace。

Examples

let mut array: [i32; 3] = [0; 3];

array[1] = 1;
array[2] = 2;

assert_eq!([1, 2], &array[1..]);

// 该循环打印: 0 1 2
for x in array {
    print!("{x} ");
}

Run

您还可以迭代数组元素的引用：

let array: [i32; 3] = [0; 3];

for x in &array { }

Run

您可以使用 <ArrayType>::try_from(slice) 或 slice.try_into() 从切片中获取数组:

let bytes: [u8; 3] = [1, 0, 2];
assert_eq!(1, u16::from_le_bytes(<[u8; 2]>::try_from(&bytes[0..2]).unwrap()));
assert_eq!(512, u16::from_le_bytes(bytes[1..3].try_into().unwrap()));

Run

您可以使用切片模式将元素移出数组：

fn move_away(_: String) { /* Do interesting things. */ }

let [john, roa] = ["John".to_string(), "Roa".to_string()];
move_away(john);
move_away(roa);

Run

可以从适当长度的同质元组创建数组:

let tuple: (u32, u32, u32) = (1, 2, 3);
let array: [u32; 3] = tuple.into();

Run

Editions

在 Rust 1.53 之前，数组没有按值实现 IntoIterator，因此调用 array.into_iter() 方法自动引用到 slice 迭代器。目前，为了兼容性，Rust 的 2015 和 2018 版本中保留了旧行为，忽略了 IntoIterator 的值。将来，2015 年和 2018 年版本的行为可能会与以后版本的行为一致。

// Rust 2015 和 2018：

let array: [i32; 3] = [0; 3];

// 这将创建一个切片迭代器，产生对每个值的引用。
for item in array.into_iter().enumerate() {
    let (i, x): (usize, &i32) = item;
    println!("array[{i}] = {x}");
}

// `array_into_iter` lint 建议进行此更改以实现未来兼容性：
for item in array.iter().enumerate() {
    let (i, x): (usize, &i32) = item;
    println!("array[{i}] = {x}");
}

// 您可以使用 `IntoIterator::into_iter` 按值显式迭代数组
for item in IntoIterator::into_iter(array).enumerate() {
    let (i, x): (usize, i32) = item;
    println!("array[{i}] = {x}");
}

Run

从 2021 版开始，array.into_iter() 通常使用 IntoIterator 进行值迭代，而应该像以前的版本一样使用 iter() 进行引用迭代。

// Rust 2021:

let array: [i32; 3] = [0; 3];

// 这通过引用进行迭代：
for item in array.iter().enumerate() {
    let (i, x): (usize, &i32) = item;
    println!("array[{i}] = {x}");
}

// 这是按值迭代的：
for item in array.into_iter().enumerate() {
    let (i, x): (usize, i32) = item;
    println!("array[{i}] = {x}");
}

Run

未来的语言版本可能会开始将 2015 和 2018 版的 array.into_iter() 语法与 2021 版相同。因此，在编写使用这些旧版本的代码时仍应牢记这一更改，以防止将来出现破坏。实现这一点最安全的方法是避免这些版本中的 into_iter 语法。如果版本更新不是不可行/不受欢迎的，则有多种选择：

使用 iter，相当于旧行为，创建引用
使用 IntoIterator::into_iter，相当于 2021 年后的行为 (Rust 1.53+)
替换为 … 在 array.into_iter() {和for … in array {`，相当于 2021 年后的行为 (Rust 1.53+)

// Rust 2015 和 2018：

let array: [i32; 3] = [0; 3];

// 这通过引用进行迭代：
for item in array.iter() {
    let x: &i32 = item;
    println!("{x}");
}

// 这是按值迭代的：
for item in IntoIterator::into_iter(array) {
    let x: i32 = item;
    println!("{x}");
}

// 这是按值迭代的：
for item in array {
    let x: i32 = item;
    println!("{x}");
}

// IntoIter 也可以启动一个链。
// 这是按值迭代的：
for item in IntoIterator::into_iter(array).enumerate() {
    let (i, x): (usize, i32) = item;
    println!("array[{i}] = {x}");
}

Primitive Type array

Implementations§

impl<T, const N: usize> [MaybeUninit<T>; N]

pub const fn transpose(self) -> MaybeUninit<[T; N]>

impl<const N: usize> [u8; N]

pub const fn as_ascii(&self) -> Option<&[Char; N]>

pub const unsafe fn as_ascii_unchecked(&self) -> &[Char; N]

impl<T, const N: usize> [T; N]

pub fn map<F, U>(self, f: F) -> [U; N]where F: FnMut(T) -> U,

pub fn try_map<F, R>( self, f: F ) -> <<R as Try>::Residual as Residual<[R::Output; N]>>::TryTypewhere F: FnMut(T) -> R, R: Try, R::Residual: Residual<[R::Output; N]>,

pub fn zip<U>(self, rhs: [U; N]) -> [(T, U); N]

pub const fn as_slice(&self) -> &[T]

pub fn as_mut_slice(&mut self) -> &mut [T]

pub fn each_ref(&self) -> [&T; N]

pub fn each_mut(&mut self) -> [&mut T; N]

pub fn split_array_ref<const M: usize>(&self) -> (&[T; M], &[T])

pub fn split_array_mut<const M: usize>(&mut self) -> (&mut [T; M], &mut [T])

pub fn rsplit_array_ref<const M: usize>(&self) -> (&[T], &[T; M])

pub fn rsplit_array_mut<const M: usize>(&mut self) -> (&mut [T], &mut [T; M])

Trait Implementations§

impl<T, const N: usize> AsMut<[T]> for [T; N]

fn as_mut(&mut self) -> &mut [T]

impl<T, const N: usize> AsMut<[T; N]> for Simd<T, N>where LaneCount<N>: SupportedLaneCount, T: SimdElement,

fn as_mut(&mut self) -> &mut [T; N]

impl<T, const N: usize> AsRef<[T]> for [T; N]

fn as_ref(&self) -> &[T]

impl<T, const N: usize> AsRef<[T; N]> for Simd<T, N>where LaneCount<N>: SupportedLaneCount, T: SimdElement,

fn as_ref(&self) -> &[T; N]

impl<T, const N: usize> Borrow<[T]> for [T; N]

fn borrow(&self) -> &[T]

impl<T, const N: usize> BorrowMut<[T]> for [T; N]

fn borrow_mut(&mut self) -> &mut [T]

impl<T: Clone, const N: usize> Clone for [T; N]

fn clone(&self) -> Self

fn clone_from(&mut self, other: &Self)

impl<T: Debug, const N: usize> Debug for [T; N]

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl<T> Default for [T; 0]

fn default() -> [T; 0]

impl<T> Default for [T; 1]where T: Default,

fn default() -> [T; 1]

impl<T> Default for [T; 10]where T: Default,

fn default() -> [T; 10]

impl<T> Default for [T; 11]where T: Default,

fn default() -> [T; 11]

impl<T> Default for [T; 12]where T: Default,

fn default() -> [T; 12]

impl<T> Default for [T; 13]where T: Default,

fn default() -> [T; 13]

impl<T> Default for [T; 14]where T: Default,

fn default() -> [T; 14]

impl<T> Default for [T; 15]where T: Default,

fn default() -> [T; 15]

impl<T> Default for [T; 16]where T: Default,

fn default() -> [T; 16]

impl<T> Default for [T; 17]where T: Default,

fn default() -> [T; 17]

impl<T> Default for [T; 18]where T: Default,

fn default() -> [T; 18]

impl<T> Default for [T; 19]where T: Default,

fn default() -> [T; 19]

impl<T> Default for [T; 2]where T: Default,

fn default() -> [T; 2]

impl<T> Default for [T; 20]where T: Default,

fn default() -> [T; 20]

impl<T> Default for [T; 21]where T: Default,

fn default() -> [T; 21]

impl<T> Default for [T; 22]where T: Default,

fn default() -> [T; 22]

impl<T> Default for [T; 23]where T: Default,

fn default() -> [T; 23]

impl<T> Default for [T; 24]where T: Default,

fn default() -> [T; 24]

impl<T> Default for [T; 25]where T: Default,

fn default() -> [T; 25]

impl<T> Default for [T; 26]where T: Default,

fn default() -> [T; 26]

impl<T> Default for [T; 27]where T: Default,

fn default() -> [T; 27]

impl<T> Default for [T; 28]where T: Default,