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:

如果元素类型允许,则大小为 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}");
}
Run

Implementations§

source§

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

source

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

🔬This is a nightly-only experimental API. (maybe_uninit_uninit_array_transpose #96097)

[MaybeUninit<T>; N] 移调为 MaybeUninit<[T; N]>

Examples
#![feature(maybe_uninit_uninit_array_transpose)]

let data = [MaybeUninit::<u8>::uninit(); 1000];
let data: MaybeUninit<[u8; 1000]> = data.transpose();
Run
source§

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

source

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

🔬This is a nightly-only experimental API. (ascii_char #110998)

将此字节数组转换为 ASCII 字符数组,如果任何字符为非 ASCII,则返回 None

Examples
#![feature(ascii_char)]
#![feature(const_option)]

const HEX_DIGITS: [std::ascii::Char; 16] =
    *b"0123456789abcdef".as_ascii().unwrap();

assert_eq!(HEX_DIGITS[1].as_str(), "1");
assert_eq!(HEX_DIGITS[10].as_str(), "a");
Run
source

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

🔬This is a nightly-only experimental API. (ascii_char #110998)

将此字节数组转换为 ASCII 字符数组,而不检查它们是否有效。

Safety

数组中的每个字节都必须在 0..=127 中,否则就是 UB。

source§

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

1.55.0 · source

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

返回大小与 self 相同的数组,并将函数 f 按顺序应用于每个元素。

如果您不一定需要新的固定大小的数组,请考虑改用 Iterator::map

关于性能和栈使用的注意事项

不幸的是,这种方法的使用目前并不总是像它们可能的那样优化。 这主要涉及大数组,因为小数组上的映射似乎优化得很好。 另请注意,在调试模式下 (即 没有任何优化),这种方法可以使用大量的栈空间 (数组大小的几倍或更多)。

因此,在性能关键的代码中,尽量避免在大型数组上使用此方法或检查发出的代码。 还要尽量避免链接 maps (例如 arr.map(...).map(...)).

在许多情况下,您可以通过在阵列上调用 .iter().into_iter() 来代替使用 Iterator::map。 只有当您真的需要一个与结果大小相同的新数组时,才需要 [T; N]::map Rust 的惰性迭代器往往会得到很好的优化。

Examples
let x = [1, 2, 3];
let y = x.map(|v| v + 1);
assert_eq!(y, [2, 3, 4]);

let x = [1, 2, 3];
let mut temp = 0;
let y = x.map(|v| { temp += 1; v * temp });
assert_eq!(y, [1, 4, 9]);

let x = ["Ferris", "Bueller's", "Day", "Off"];
let y = x.map(|v| v.len());
assert_eq!(y, [6, 9, 3, 3]);
Run
source

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]>,

🔬This is a nightly-only experimental API. (array_try_map #79711)

一个容易出错的函数 f 应用于数组 self 上的每个元素,以返回与 self 或遇到的第一个错误大小相同的数组。

这个函数的返回类型取决于闭包的返回类型。 如果您从闭包返回 Result<T, E>,您会得到一个 Result<[T; N], E>. 如果您从闭包中返回 Option<T>,您会得到一个 Option<[T; N]>.

Examples
#![feature(array_try_map)]
let a = ["1", "2", "3"];
let b = a.try_map(|v| v.parse::<u32>()).unwrap().map(|v| v + 1);
assert_eq!(b, [2, 3, 4]);

let a = ["1", "2a", "3"];
let b = a.try_map(|v| v.parse::<u32>());
assert!(b.is_err());

use std::num::NonZeroU32;
let z = [1, 2, 0, 3, 4];
assert_eq!(z.try_map(NonZeroU32::new), None);
let a = [1, 2, 3];
let b = a.try_map(NonZeroU32::new);
let c = b.map(|x| x.map(NonZeroU32::get));
assert_eq!(c, Some(a));
Run
source

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

🔬This is a nightly-only experimental API. (array_zip #80094)

将两个阵列压缩为成对的单个阵列。

zip() 返回一个新数组,其中每个元素都是一个元组,其中第一个元素来自第一个数组,第二个元素来自第二个数组。

换句话说,它将两个数组压缩在一起,成为一个数组。

Examples
#![feature(array_zip)]
let x = [1, 2, 3];
let y = [4, 5, 6];
let z = x.zip(y);
assert_eq!(z, [(1, 4), (2, 5), (3, 6)]);
Run
1.57.0 (const: 1.57.0) · source

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

返回包含整个数组的切片。等效于 &s[..]

1.57.0 · source

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

返回包含整个数组的可变切片。 等效于 &mut s[..]

source

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

🔬This is a nightly-only experimental API. (array_methods #76118)

借用每个元素,并返回一个引用数组,其大小与 self 相同。

Example
#![feature(array_methods)]

let floats = [3.1, 2.7, -1.0];
let float_refs: [&f64; 3] = floats.each_ref();
assert_eq!(float_refs, [&3.1, &2.7, &-1.0]);
Run

如果与其他方法 (例如 map) 结合使用,则此方法特别有用。 这样,如果原始数组的元素不是 Copy,则可以避免移动原始数组。

#![feature(array_methods)]

let strings = ["Ferris".to_string(), "♥".to_string(), "Rust".to_string()];
let is_ascii = strings.each_ref().map(|s| s.is_ascii());
assert_eq!(is_ascii, [true, false, true]);

// 我们仍然可以访问原始数组:它尚未移动。
assert_eq!(strings.len(), 3);
Run
source

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

🔬This is a nightly-only experimental API. (array_methods #76118)

借用每个元素,并返回与 self 相同大小的可变引用数组。

Example
#![feature(array_methods)]

let mut floats = [3.1, 2.7, -1.0];
let float_refs: [&mut f64; 3] = floats.each_mut();
*float_refs[0] = 0.0;
assert_eq!(float_refs, [&mut 0.0, &mut 2.7, &mut -1.0]);
assert_eq!(floats, [0.0, 2.7, -1.0]);
Run
source

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

🔬This is a nightly-only experimental API. (split_array #90091)

在一个索引处将一个数组的引用一分为二。

第一个将包含来自 [0, M) 的所有索引 (不包括索引 M 本身),第二个将包含来自 [M, N) 的所有索引 (不包括索引 N 本身)。

Panics

如果 M > N,就会出现 panics。

Examples
#![feature(split_array)]

let v = [1, 2, 3, 4, 5, 6];

{
   let (left, right) = v.split_array_ref::<0>();
   assert_eq!(left, &[]);
   assert_eq!(right, &[1, 2, 3, 4, 5, 6]);
}

{
    let (left, right) = v.split_array_ref::<2>();
    assert_eq!(left, &[1, 2]);
    assert_eq!(right, &[3, 4, 5, 6]);
}

{
    let (left, right) = v.split_array_ref::<6>();
    assert_eq!(left, &[1, 2, 3, 4, 5, 6]);
    assert_eq!(right, &[]);
}
Run
source

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

🔬This is a nightly-only experimental API. (split_array #90091)

在一个索引处将一个可变数组的引用一分为二。

第一个将包含来自 [0, M) 的所有索引 (不包括索引 M 本身),第二个将包含来自 [M, N) 的所有索引 (不包括索引 N 本身)。

Panics

如果 M > N,就会出现 panics。

Examples
#![feature(split_array)]

let mut v = [1, 0, 3, 0, 5, 6];
let (left, right) = v.split_array_mut::<2>();
assert_eq!(left, &mut [1, 0][..]);
assert_eq!(right, &mut [3, 0, 5, 6]);
left[1] = 2;
right[1] = 4;
assert_eq!(v, [1, 2, 3, 4, 5, 6]);
Run
source

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

🔬This is a nightly-only experimental API. (split_array #90091)

将一个数组引用从末尾的一个索引处一分为二。

第一个将包含来自 [0, N - M) 的所有索引 (不包括索引 N - M 本身),第二个将包含来自 [N - M, N) 的所有索引 (不包括索引 N 本身)。

Panics

如果 M > N,就会出现 panics。

Examples
#![feature(split_array)]

let v = [1, 2, 3, 4, 5, 6];

{
   let (left, right) = v.rsplit_array_ref::<0>();
   assert_eq!(left, &[1, 2, 3, 4, 5, 6]);
   assert_eq!(right, &[]);
}

{
    let (left, right) = v.rsplit_array_ref::<2>();
    assert_eq!(left, &[1, 2, 3, 4]);
    assert_eq!(right, &[5, 6]);
}

{
    let (left, right) = v.rsplit_array_ref::<6>();
    assert_eq!(left, &[]);
    assert_eq!(right, &[1, 2, 3, 4, 5, 6]);
}
Run
source

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

🔬This is a nightly-only experimental API. (split_array #90091)

将一个附属数组引用从末尾的一个索引处一分为二。

第一个将包含来自 [0, N - M) 的所有索引 (不包括索引 N - M 本身),第二个将包含来自 [N - M, N) 的所有索引 (不包括索引 N 本身)。

Panics

如果 M > N,就会出现 panics。

Examples
#![feature(split_array)]

let mut v = [1, 0, 3, 0, 5, 6];
let (left, right) = v.rsplit_array_mut::<4>();
assert_eq!(left, &mut [1, 0]);
assert_eq!(right, &mut [3, 0, 5, 6][..]);
left[1] = 2;
right[1] = 4;
assert_eq!(v, [1, 2, 3, 4, 5, 6]);
Run

Trait Implementations§

source§

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

source§

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

将此类型转换为 (通常是推断的) 输入类型的错误引用。
source§

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

source§

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

将此类型转换为 (通常是推断的) 输入类型的错误引用。
source§

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

source§

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

将此类型转换为 (通常是推断的) 输入类型的共享引用。
source§

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

source§

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

将此类型转换为 (通常是推断的) 输入类型的共享引用。
1.4.0 · source§

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

source§

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

从拥有的值中一成不变地借用。 Read more
1.4.0 · source§

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

source§

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

从拥有的值中借用。 Read more
1.58.0 · source§

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

source§

fn clone(&self) -> Self

返回值的副本。 Read more
source§

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

source 执行复制分配。 Read more
source§

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

source§

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

使用给定的格式化程序格式化该值。 Read more
1.4.0 · source§

impl<T> Default for [T; 0]

source§

fn default() -> [T; 0]

返回类型的 “默认值”。 Read more
1.4.0 · source§

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

source§

fn default() -> [T; 1]

返回类型的 “默认值”。 Read more
1.4.0 · source§

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

source§

fn default() -> [T; 10]

返回类型的 “默认值”。 Read more
1.4.0 · source§

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

source§

fn default() -> [T; 11]

返回类型的 “默认值”。 Read more
1.4.0 · source§

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

source§

fn default() -> [T; 12]

返回类型的 “默认值”。 Read more
1.4.0 · source§

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

source§

fn default() -> [T; 13]

返回类型的 “默认值”。 Read more
1.4.0 · source§

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

source§

fn default() -> [T; 14]

返回类型的 “默认值”。 Read more
1.4.0 · source§

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

source§

fn default() -> [T; 15]

返回类型的 “默认值”。 Read more
1.4.0 · source§

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

source§

fn default() -> [T; 16]

返回类型的 “默认值”。 Read more
1.4.0 · source§

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

source§

fn default() -> [T; 17]

返回类型的 “默认值”。 Read more
1.4.0 · source§

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

source§

fn default() -> [T; 18]

返回类型的 “默认值”。 Read more
1.4.0 · source§

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

source§

fn default() -> [T; 19]

返回类型的 “默认值”。 Read more
1.4.0 · source§

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

source§

fn default() -> [T; 2]

返回类型的 “默认值”。 Read more
1.4.0 · source§

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

source§

fn default() -> [T; 20]

返回类型的 “默认值”。 Read more
1.4.0 · source§

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

source§

fn default() -> [T; 21]

返回类型的 “默认值”。 Read more
1.4.0 · source§

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

source§

fn default() -> [T; 22]

返回类型的 “默认值”。 Read more
1.4.0 · source§

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

source§

fn default() -> [T; 23]

返回类型的 “默认值”。 Read more
1.4.0 · source§

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

source§

fn default() -> [T; 24]

返回类型的 “默认值”。 Read more
1.4.0 · source§

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

source§

fn default() -> [T; 25]

返回类型的 “默认值”。 Read more
1.4.0 · source§

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

source§

fn default() -> [T; 26]

返回类型的 “默认值”。 Read more
1.4.0 · source§

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

source§

fn default() -> [T; 27]

返回类型的 “默认值”。 Read more
1.4.0 · source§

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

source§

fn default() -> [T; 28]

返回类型的 “默认值”。 Read more
1.4.0 · source§

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

source§

fn default() -> [T; 29]

返回类型的 “默认值”。 Read more
1.4.0 · source§

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

source§

fn default() -> [T; 3]

返回类型的 “默认值”。 Read more
1.4.0 · source§

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

source§

fn default() -> [T; 30]

返回类型的 “默认值”。 Read more
1.4.0 · source§

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

source§

fn default() -> [T; 31]

返回类型的 “默认值”。 Read more
1.4.0 · source§

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

source§

fn default() -> [T; 32]

返回类型的 “默认值”。 Read more
1.4.0 · source§

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

source§

fn default() -> [T; 4]

返回类型的 “默认值”。 Read more
1.4.0 · source§

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

source§

fn default() -> [T; 5]

返回类型的 “默认值”。 Read more
1.4.0 · source§

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

source§

fn default() -> [T; 6]

返回类型的 “默认值”。 Read more
1.4.0 · source§

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

source§

fn default() -> [T; 7]

返回类型的 “默认值”。 Read more
1.4.0 · source§

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

source§

fn default() -> [T; 8]

返回类型的 “默认值”。 Read more
1.4.0 · source§

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

source§

fn default() -> [T; 9]

返回类型的 “默认值”。 Read more
1.71.0 · source§

impl<T> From<[T; 1]> for (T,)

source§

fn from(array: [T; 1]) -> Self

从输入类型转换为此类型。
1.71.0 · source§

impl<T> From<[T; 10]> for (T, T, T, T, T, T, T, T, T, T)

source§

fn from(array: [T; 10]) -> Self

从输入类型转换为此类型。
1.71.0 · source§

impl<T> From<[T; 11]> for (T, T, T, T, T, T, T, T, T, T, T)

source§

fn from(array: [T; 11]) -> Self

从输入类型转换为此类型。
1.71.0 · source§

impl<T> From<[T; 12]> for (T, T, T, T, T, T, T, T, T, T, T, T)

source§

fn from(array: [T; 12]) -> Self

从输入类型转换为此类型。
1.71.0 · source§

impl<T> From<[T; 2]> for (T, T)

source§

fn from(array: [T; 2]) -> Self

从输入类型转换为此类型。
1.71.0 · source§

impl<T> From<[T; 3]> for (T, T, T)

source§

fn from(array: [T; 3]) -> Self

从输入类型转换为此类型。
1.71.0 · source§

impl<T> From<[T; 4]> for (T, T, T, T)

source§

fn from(array: [T; 4]) -> Self

从输入类型转换为此类型。
1.71.0 · source§

impl<T> From<[T; 5]> for (T, T, T, T, T)

source§

fn from(array: [T; 5]) -> Self

从输入类型转换为此类型。
1.71.0 · source§

impl<T> From<[T; 6]> for (T, T, T, T, T, T)

source§

fn from(array: [T; 6]) -> Self

从输入类型转换为此类型。
1.71.0 · source§

impl<T> From<[T; 7]> for (T, T, T, T, T, T, T)

source§

fn from(array: [T; 7]) -> Self

从输入类型转换为此类型。
1.71.0 · source§

impl<T> From<[T; 8]> for (T, T, T, T, T, T, T, T)

source§

fn from(array: [T; 8]) -> Self

从输入类型转换为此类型。
1.71.0 · source§

impl<T> From<[T; 9]> for (T, T, T, T, T, T, T, T, T)

source§

fn from(array: [T; 9]) -> Self

从输入类型转换为此类型。
source§

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

source§

fn from(array: [T; N]) -> Self

从输入类型转换为此类型。
source§

impl<T, const LANES: usize> From<[bool; LANES]> for Mask<T, LANES>where T: MaskElement, LaneCount<LANES>: SupportedLaneCount,

source§

fn from(array: [bool; LANES]) -> Self

从输入类型转换为此类型。
1.17.0 · source§

impl From<[u16; 8]> for IpAddr

source§

fn from(segments: [u16; 8]) -> IpAddr

从 8 个元素的 16 位数组创建 IpAddr::V6

Examples
use std::net::{IpAddr, Ipv6Addr};

let addr = IpAddr::from([
    525u16, 524u16, 523u16, 522u16,
    521u16, 520u16, 519u16, 518u16,
]);
assert_eq!(
    IpAddr::V6(Ipv6Addr::new(
        0x20d, 0x20c,
        0x20b, 0x20a,
        0x209, 0x208,
        0x207, 0x206
    )),
    addr
);
Run
1.16.0 · source§

impl From<[u16; 8]> for Ipv6Addr

source§

fn from(segments: [u16; 8]) -> Ipv6Addr

从 8 个元素的 16 位数组创建 Ipv6Addr

Examples
use std::net::Ipv6Addr;

let addr = Ipv6Addr::from([
    525u16, 524u16, 523u16, 522u16,
    521u16, 520u16, 519u16, 518u16,
]);
assert_eq!(
    Ipv6Addr::new(
        0x20d, 0x20c,
        0x20b, 0x20a,
        0x209, 0x208,
        0x207, 0x206
    ),
    addr
);
Run
1.17.0 · source§

impl From<[u8; 16]> for IpAddr

source§

fn from(octets: [u8; 16]) -> IpAddr

从 16 个元素的字节数组创建 IpAddr::V6

Examples
use std::net::{IpAddr, Ipv6Addr};

let addr = IpAddr::from([
    25u8, 24u8, 23u8, 22u8, 21u8, 20u8, 19u8, 18u8,
    17u8, 16u8, 15u8, 14u8, 13u8, 12u8, 11u8, 10u8,
]);
assert_eq!(
    IpAddr::V6(Ipv6Addr::new(
        0x1918, 0x1716,
        0x1514, 0x1312,
        0x1110, 0x0f0e,
        0x0d0c, 0x0b0a
    )),
    addr
);
Run
1.9.0 · source§

impl From<[u8; 16]> for Ipv6Addr

source§

fn from(octets: [u8; 16]) -> Ipv6Addr

从 16 个元素的字节数组创建 Ipv6Addr

Examples
use std::net::Ipv6Addr;

let addr = Ipv6Addr::from([
    25u8, 24u8, 23u8, 22u8, 21u8, 20u8, 19u8, 18u8,
    17u8, 16u8, 15u8, 14u8, 13u8, 12u8, 11u8, 10u8,
]);
assert_eq!(
    Ipv6Addr::new(
        0x1918, 0x1716,
        0x1514, 0x1312,
        0x1110, 0x0f0e,
        0x0d0c, 0x0b0a
    ),
    addr
);
Run
1.17.0 · source§

impl From<[u8; 4]> for IpAddr

source§

fn from(octets: [u8; 4]) -> IpAddr

从一个四元素字节数组创建一个 IpAddr::V4

Examples
use std::net::{IpAddr, Ipv4Addr};

let addr = IpAddr::from([13u8, 12u8, 11u8, 10u8]);
assert_eq!(IpAddr::V4(Ipv4Addr::new(13, 12, 11, 10)), addr);
Run
1.9.0 · source§

impl From<[u8; 4]> for Ipv4Addr

source§

fn from(octets: [u8; 4]) -> Ipv4Addr

从一个四元素字节数组创建一个 Ipv4Addr

Examples
use std::net::Ipv4Addr;

let addr = Ipv4Addr::from([13u8, 12u8, 11u8, 10u8]);
assert_eq!(Ipv4Addr::new(13, 12, 11, 10), addr);
Run
1.71.0 · source§

impl<T> From<(T,)> for [T; 1]

source§

fn from(tuple: (T,)) -> Self

从输入类型转换为此类型。
1.71.0 · source§

impl<T> From<(T, T)> for [T; 2]

source§

fn from(tuple: (T, T)) -> Self

从输入类型转换为此类型。
1.71.0 · source§

impl<T> From<(T, T, T)> for [T; 3]

source§

fn from(tuple: (T, T, T)) -> Self

从输入类型转换为此类型。
1.71.0 · source§

impl<T> From<(T, T, T, T)> for [T; 4]

source§

fn from(tuple: (T, T, T, T)) -> Self

从输入类型转换为此类型。
1.71.0 · source§

impl<T> From<(T, T, T, T, T)> for [T; 5]

source§

fn from(tuple: (T, T, T, T, T)) -> Self

从输入类型转换为此类型。
1.71.0 · source§

impl<T> From<(T, T, T, T, T, T)> for [T; 6]

source§

fn from(tuple: (T, T, T, T, T, T)) -> Self

从输入类型转换为此类型。
1.71.0 · source§

impl<T> From<(T, T, T, T, T, T, T)> for [T; 7]

source§

fn from(tuple: (T, T, T, T, T, T, T)) -> Self

从输入类型转换为此类型。
1.71.0 · source§

impl<T> From<(T, T, T, T, T, T, T, T)> for [T; 8]

source§

fn from(tuple: (T, T, T, T, T, T, T, T)) -> Self

从输入类型转换为此类型。
1.71.0 · source§

impl<T> From<(T, T, T, T, T, T, T, T, T)> for [T; 9]

source§

fn from(tuple: (T, T, T, T, T, T, T, T, T)) -> Self

从输入类型转换为此类型。
1.71.0 · source§

impl<T> From<(T, T, T, T, T, T, T, T, T, T)> for [T; 10]

source§

fn from(tuple: (T, T, T, T, T, T, T, T, T, T)) -> Self

从输入类型转换为此类型。
1.71.0 · source§

impl<T> From<(T, T, T, T, T, T, T, T, T, T, T)> for [T; 11]

source§

fn from(tuple: (T, T, T, T, T, T, T, T, T, T, T)) -> Self

从输入类型转换为此类型。
1.71.0 · source§

impl<T> From<(T, T, T, T, T, T, T, T, T, T, T, T)> for [T; 12]

source§

fn from(tuple: (T, T, T, T, T, T, T, T, T, T, T, T)) -> Self

从输入类型转换为此类型。
source§

impl<T, const LANES: usize> From<Mask<T, LANES>> for [bool; LANES]where T: MaskElement, LaneCount<LANES>: SupportedLaneCount,

source§

fn from(vector: Mask<T, LANES>) -> Self

从输入类型转换为此类型。
source§

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

source§

fn from(vector: Simd<T, N>) -> Self

从输入类型转换为此类型。
source§

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

数组的哈希值与对应的 X 像素的哈希值相同,符合实现的要求。

use std::hash::BuildHasher;

let b = std::collections::hash_map::RandomState::new();
let a: [u8; 3] = [0xa8, 0x3c, 0x09];
let s: &[u8] = &[0xa8, 0x3c, 0x09];
assert_eq!(b.hash_one(a), b.hash_one(s));
Run
source§

fn hash<H: Hasher>(&self, state: &mut H)

将该值输入给定的 HasherRead more
1.3.0 · source§

fn hash_slice<H: Hasher>(data: &[Self], state: &mut H)where Self: Sized,

将这种类型的切片送入给定的 Hasher 中。 Read more
1.50.0 · source§

impl<T, I, const N: usize> Index<I> for [T; N]where [T]: Index<I>,

§

type Output = <[T] as Index<I>>::Output

索引后返回的类型。
source§

fn index(&self, index: I) -> &Self::Output

执行索引 (container[index]) 操作。 Read more
1.50.0 · source§

impl<T, I, const N: usize> IndexMut<I> for [T; N]where [T]: IndexMut<I>,

source§

fn index_mut(&mut self, index: I) -> &mut Self::Output

执行可变索引 (container[index]) 操作。 Read more
source§

impl<'a, T, const N: usize> IntoIterator for &'a [T; N]

§

type Item = &'a T

被迭代的元素的类型。
§

type IntoIter = Iter<'a, T>

我们将其变成哪种迭代器?
source§

fn into_iter(self) -> Iter<'a, T>

从一个值创建一个迭代器。 Read more
source§

impl<'a, T, const N: usize> IntoIterator for &'a mut [T; N]

§

type Item = &'a mut T

被迭代的元素的类型。
§

type IntoIter = IterMut<'a, T>

我们将其变成哪种迭代器?
source§

fn into_iter(self) -> IterMut<'a, T>

从一个值创建一个迭代器。 Read more
1.53.0 · source§

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

source§

fn into_iter(self) -> Self::IntoIter

创建一个消费迭代器,即将每个值移出数组 (从开始到结束)。 除非 T 实现了 Copy,否则调用此数组后不能使用数组,因此整个数组都会被复制。

在调用 .into_iter() 之前,数组具有特殊行为 2021 版 – 有关更多信息,请参见 array 版本部分。

§

type Item = T

被迭代的元素的类型。
§

type IntoIter = IntoIter<T, N>

我们将其变成哪种迭代器?
source§

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

实现数组 按字典顺序 的比较。

source§

fn cmp(&self, other: &[T; N]) -> Ordering

此方法返回 selfother 之间的 OrderingRead more
1.21.0 · source§

fn max(self, other: Self) -> Selfwhere Self: Sized,

比较并返回两个值中的最大值。 Read more
1.21.0 · source§

fn min(self, other: Self) -> Selfwhere Self: Sized,

比较并返回两个值中的最小值。 Read more
1.50.0 · source§

fn clamp(self, min: Self, max: Self) -> Selfwhere Self: Sized + PartialOrd,

将值限制在某个时间间隔内。 Read more
source§

impl<A, B, const N: usize> PartialEq<&[B]> for [A; N]where A: PartialEq<B>,

source§

fn eq(&self, other: &&[B]) -> bool

此方法测试 selfother 值是否相等,并由 == 使用。
source§

fn ne(&self, other: &&[B]) -> bool

此方法测试 !=。 默认实现几乎总是足够的,并且不应在没有充分理由的情况下被覆盖。
source§

impl<A, B, const N: usize> PartialEq<&mut [B]> for [A; N]where A: PartialEq<B>,

source§

fn eq(&self, other: &&mut [B]) -> bool

此方法测试 selfother 值是否相等,并由 == 使用。
source§

fn ne(&self, other: &&mut [B]) -> bool

此方法测试 !=。 默认实现几乎总是足够的,并且不应在没有充分理由的情况下被覆盖。
source§

impl<A, B, const N: usize> PartialEq<[A; N]> for &[B]where B: PartialEq<A>,

source§

fn eq(&self, other: &[A; N]) -> bool

此方法测试 selfother 值是否相等,并由 == 使用。
source§

fn ne(&self, other: &[A; N]) -> bool

此方法测试 !=。 默认实现几乎总是足够的,并且不应在没有充分理由的情况下被覆盖。
source§

impl<A, B, const N: usize> PartialEq<[A; N]> for &mut [B]where B: PartialEq<A>,

source§

fn eq(&self, other: &[A; N]) -> bool

此方法测试 selfother 值是否相等,并由 == 使用。
source§

fn ne(&self, other: &[A; N]) -> bool

此方法测试 !=。 默认实现几乎总是足够的,并且不应在没有充分理由的情况下被覆盖。
source§

impl<A, B, const N: usize> PartialEq<[A; N]> for [B]where B: PartialEq<A>,

source§

fn eq(&self, other: &[A; N]) -> bool

此方法测试 selfother 值是否相等,并由 == 使用。
source§

fn ne(&self, other: &[A; N]) -> bool

此方法测试 !=。 默认实现几乎总是足够的,并且不应在没有充分理由的情况下被覆盖。
source§

impl<A, B, const N: usize> PartialEq<[B]> for [A; N]where A: PartialEq<B>,

source§

fn eq(&self, other: &[B]) -> bool

此方法测试 selfother 值是否相等,并由 == 使用。
source§

fn ne(&self, other: &[B]) -> bool

此方法测试 !=。 默认实现几乎总是足够的,并且不应在没有充分理由的情况下被覆盖。
source§

impl<A, B, const N: usize> PartialEq<[B; N]> for [A; N]where A: PartialEq<B>,

source§

fn eq(&self, other: &[B; N]) -> bool

此方法测试 selfother 值是否相等,并由 == 使用。
source§

fn ne(&self, other: &[B; N]) -> bool

此方法测试 !=。 默认实现几乎总是足够的,并且不应在没有充分理由的情况下被覆盖。
source§

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

source§

fn partial_cmp(&self, other: &[T; N]) -> Option<Ordering>

如果存在,则此方法返回 selfother 值之间的顺序。 Read more
source§

fn lt(&self, other: &[T; N]) -> bool

此方法测试的内容少于 (对于 selfother),并且由 < 操作员使用。 Read more
source§

fn le(&self, other: &[T; N]) -> bool

此方法测试小于或等于 (对于 selfother),并且由 <= 运算符使用。 Read more
source§

fn ge(&self, other: &[T; N]) -> bool

此方法测试是否大于或等于 (对于 selfother),并且由 >= 运算符使用。 Read more
source§

fn gt(&self, other: &[T; N]) -> bool

此方法测试大于 (对于 selfother),并且由 > 操作员使用。 Read more
source§

impl<'a, 'b, const N: usize> Pattern<'a> for &'b [char; N]

搜索等于数组中任何 char 的字符。

Examples

assert_eq!("Hello world".find(&['o', 'l']), Some(2));
assert_eq!("Hello world".find(&['h', 'w']), Some(6));
Run
§

type Searcher = CharArrayRefSearcher<'a, 'b, N>

🔬This is a nightly-only experimental API. (pattern #27721)
此模式的关联搜索者
source§

fn into_searcher(self, haystack: &'a str) -> CharArrayRefSearcher<'a, 'b, N>

🔬This is a nightly-only experimental API. (pattern #27721)
selfhaystack 构造关联的搜索器以进行搜索。
source§

fn is_contained_in(self, haystack: &'a str) -> bool

🔬This is a nightly-only experimental API. (pattern #27721)
检查模式是否与 haystack 中的任何位置匹配
source§

fn is_prefix_of(self, haystack: &'a str) -> bool

🔬This is a nightly-only experimental API. (pattern #27721)
检查模式是否在 haystack 的前面匹配
source§

fn strip_prefix_of(self, haystack: &'a str) -> Option<&'a str>

🔬This is a nightly-only experimental API. (pattern #27721)
如果匹配,则从 haystack 的正面删除模式。
source§

fn is_suffix_of(self, haystack: &'a str) -> boolwhere CharArrayRefSearcher<'a, 'b, N>: ReverseSearcher<'a>,

🔬This is a nightly-only experimental API. (pattern #27721)
检查模式是否与 haystack 的后面匹配
source§

fn strip_suffix_of(self, haystack: &'a str) -> Option<&'a str>where CharArrayRefSearcher<'a, 'b, N>: ReverseSearcher<'a>,

🔬This is a nightly-only experimental API. (pattern #27721)
如果匹配,则从 haystack 的后面删除模式。
source§

impl<'a, const N: usize> Pattern<'a> for [char; N]

搜索等于数组中任何 char 的字符。

Examples

assert_eq!("Hello world".find(['o', 'l']), Some(2));
assert_eq!("Hello world".find(['h', 'w']), Some(6));
Run
§

type Searcher = CharArraySearcher<'a, N>

🔬This is a nightly-only experimental API. (pattern #27721)
此模式的关联搜索者
source§

fn into_searcher(self, haystack: &'a str) -> CharArraySearcher<'a, N>

🔬This is a nightly-only experimental API. (pattern #27721)
selfhaystack 构造关联的搜索器以进行搜索。
source§

fn is_contained_in(self, haystack: &'a str) -> bool

🔬This is a nightly-only experimental API. (pattern #27721)
检查模式是否与 haystack 中的任何位置匹配
source§

fn is_prefix_of(self, haystack: &'a str) -> bool

🔬This is a nightly-only experimental API. (pattern #27721)
检查模式是否在 haystack 的前面匹配
source§

fn strip_prefix_of(self, haystack: &'a str) -> Option<&'a str>

🔬This is a nightly-only experimental API. (pattern #27721)
如果匹配,则从 haystack 的正面删除模式。
source§

fn is_suffix_of(self, haystack: &'a str) -> boolwhere CharArraySearcher<'a, N>: ReverseSearcher<'a>,

🔬This is a nightly-only experimental API. (pattern #27721)
检查模式是否与 haystack 的后面匹配
source§

fn strip_suffix_of(self, haystack: &'a str) -> Option<&'a str>where CharArraySearcher<'a, N>: ReverseSearcher<'a>,

🔬This is a nightly-only experimental API. (pattern #27721)
如果匹配,则从 haystack 的后面删除模式。
1.51.0 · source§

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

§

type Item = T

🔬This is a nightly-only experimental API. (slice_pattern #56345)
匹配的切片的元素类型。
source§

fn as_slice(&self) -> &[Self::Item]

🔬This is a nightly-only experimental API. (slice_pattern #56345)
当前,SlicePattern 的消费者需要切片。
1.34.0 · source§

impl<T, const N: usize> TryFrom<&[T]> for [T; N]where T: Copy,

尝试通过从切片 &[T] 复制来创建数组 [T; N]。 如果 slice.len() == N 则成功。

let bytes: [u8; 3] = [1, 0, 2];

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

let bytes_tail: [u8; 2] = bytes[1..3].try_into().unwrap();
assert_eq!(512, u16::from_le_bytes(bytes_tail));
Run
§

type Error = TryFromSliceError

发生转换错误时返回的类型。
source§

fn try_from(slice: &[T]) -> Result<[T; N], TryFromSliceError>

执行转换。
1.34.0 · source§

impl<'a, T, const N: usize> TryFrom<&'a [T]> for &'a [T; N]

尝试从切片 ref &[T] 创建数组 ref &[T; N]。 如果 slice.len() == N 则成功。

let bytes: [u8; 3] = [1, 0, 2];

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

let bytes_tail: &[u8; 2] = bytes[1..3].try_into().unwrap();
assert_eq!(512, u16::from_le_bytes(*bytes_tail));
Run
§

type Error = TryFromSliceError

发生转换错误时返回的类型。
source§

fn try_from(slice: &'a [T]) -> Result<&'a [T; N], TryFromSliceError>

执行转换。
1.34.0 · source§

impl<'a, T, const N: usize> TryFrom<&'a mut [T]> for &'a mut [T; N]

尝试从一个非线性切片 ref &mut [T] 创建一个非线性数组 ref &mut [T; N]。 如果 slice.len() == N 则成功。

let mut bytes: [u8; 3] = [1, 0, 2];

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

let bytes_tail: &mut [u8; 2] = (&mut bytes[1..3]).try_into().unwrap();
assert_eq!(512, u16::from_le_bytes(*bytes_tail));
Run
§

type Error = TryFromSliceError

发生转换错误时返回的类型。
source§

fn try_from(slice: &'a mut [T]) -> Result<&'a mut [T; N], TryFromSliceError>

执行转换。
1.59.0 · source§

impl<T, const N: usize> TryFrom<&mut [T]> for [T; N]where T: Copy,

尝试通过从无效切片 &mut [T] 复制来创建数组 [T; N]。 如果 slice.len() == N 则成功。

let mut bytes: [u8; 3] = [1, 0, 2];

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

let bytes_tail: [u8; 2] = (&mut bytes[1..3]).try_into().unwrap();
assert_eq!(512, u16::from_le_bytes(bytes_tail));
Run
§

type Error = TryFromSliceError

发生转换错误时返回的类型。
source§

fn try_from(slice: &mut [T]) -> Result<[T; N], TryFromSliceError>

执行转换。
source§

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

1.58.0 · source§

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

source§

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

source§

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

Auto Trait Implementations§

§

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

§

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

§

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

§

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

§

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

Blanket Implementations§

source§

impl<T> Any for Twhere T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

获取 selfTypeIdRead more
source§

impl<T> Borrow<T> for Twhere T: ?Sized,

source§

fn borrow(&self) -> &T

从拥有的值中一成不变地借用。 Read more
source§

impl<T> BorrowMut<T> for Twhere T: ?Sized,

source§

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

从拥有的值中借用。 Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

返回未更改的参数。

source§

impl<T, U> Into<U> for Twhere U: From<T>,

source§

fn into(self) -> U

调用 U::from(self)

也就是说,这种转换是 From<T> for U 实现选择执行的任何操作。

source§

impl<T, U> TryFrom<U> for Twhere U: Into<T>,

§

type Error = Infallible

发生转换错误时返回的类型。
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

执行转换。
source§

impl<T, U> TryInto<U> for Twhere U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

发生转换错误时返回的类型。
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

执行转换。