Primitive Type array

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

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

• 包含每个元素的列表，即 [x, y, z]。
• 重复表达式 [x; N]，该数组生成包含 x 的 N 副本的数组。 x 的类型必须为 Copy。

请注意，[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。

数组强制转换为 slices ([T]) ，因此可以在数组上调用 slice 方法。实际上，这提供了用于处理数组的大多数 API。 切片具有动态大小，并且不强制转换为数组。

您可以使用 切片模式 将元素移出数组。如果需要一个元素，请参见 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);
}

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

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

for x in &array { }

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

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

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

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);
}

从 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);
}

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

• 使用 iter，相当于旧行为，创建引用
• 使用 IntoIterator::into_iter，相当于 2021 年后的行为 (Rust 1.53+)
• 替换 for .... in 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);
}

Implementations

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

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]);

pub fn try_map<F, R>(
    self,
    f: F
) -> <<R as Try>::Residual as Residual<[<R as Try>::Output; N]>>::TryType where
    F: FnMut(T) -> R,
    R: Try,
    <R as Try>::Residual: Residual<[<R as Try>::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));

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)]);

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

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

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

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

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]);

如果与其他方法 (例如 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);

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]);

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, &[]);
}

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]);

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]);
}

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]);

Trait Implementations

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

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

执行转换。

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

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

执行转换。

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

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

执行转换。

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

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

执行转换。

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

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

从拥有的值中一成不变地借用。

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

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

从拥有的值中借用。

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

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

返回值的副本。

pub fn clone_from(&mut self, other: &[T; N])

从 source 执行复制分配。

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

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

使用给定的格式化程序格式化该值。

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

pub fn default() -> [T; 6]

返回类型的 “默认值”。

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

pub fn default() -> [T; 23]

返回类型的 “默认值”。

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

pub fn default() -> [T; 1]

返回类型的 “默认值”。

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

pub fn default() -> [T; 11]

返回类型的 “默认值”。

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

pub fn default() -> [T; 12]

返回类型的 “默认值”。

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

pub fn default() -> [T; 3]

返回类型的 “默认值”。

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

pub fn default() -> [T; 9]

返回类型的 “默认值”。

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

pub fn default() -> [T; 16]

返回类型的 “默认值”。

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

pub fn default() -> [T; 30]

返回类型的 “默认值”。

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

pub fn default() -> [T; 18]

返回类型的 “默认值”。

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

pub fn default() -> [T; 27]

返回类型的 “默认值”。

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

pub fn default() -> [T; 10]

返回类型的 “默认值”。

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

pub fn default() -> [T; 26]

返回类型的 “默认值”。

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

pub fn default() -> [T; 25]

返回类型的 “默认值”。

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

pub fn default() -> [T; 22]

返回类型的 “默认值”。

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

pub fn default() -> [T; 21]

返回类型的 “默认值”。

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

pub fn default() -> [T; 2]

返回类型的 “默认值”。

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

pub fn default() -> [T; 7]

返回类型的 “默认值”。

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

pub fn default() -> [T; 17]

返回类型的 “默认值”。

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

pub fn default() -> [T; 28]

返回类型的 “默认值”。

impl<T> Default for [T; 0]

pub fn default() -> [T; 0]

返回类型的 “默认值”。

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

pub fn default() -> [T; 5]

返回类型的 “默认值”。

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

pub fn default() -> [T; 4]

返回类型的 “默认值”。

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

pub fn default() -> [T; 32]

返回类型的 “默认值”。

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

pub fn default() -> [T; 8]

返回类型的 “默认值”。

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

pub fn default() -> [T; 20]

返回类型的 “默认值”。

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

pub fn default() -> [T; 15]

返回类型的 “默认值”。

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

pub fn default() -> [T; 19]

返回类型的 “默认值”。

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

pub fn default() -> [T; 29]

返回类型的 “默认值”。

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

pub fn default() -> [T; 31]

返回类型的 “默认值”。

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

pub fn default() -> [T; 13]

返回类型的 “默认值”。

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

pub fn default() -> [T; 14]

返回类型的 “默认值”。

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

pub fn default() -> [T; 24]

返回类型的 “默认值”。

impl<K, V, const N: usize> From<[(K, V); N]> for BTreeMap<K, V> where
    K: Ord, 

pub fn from(arr: [(K, V); N]) -> BTreeMap<K, V>

use std::collections::BTreeMap;

let map1 = BTreeMap::from([(1, 2), (3, 4)]);
let map2: BTreeMap<_, _> = [(1, 2), (3, 4)].into();
assert_eq!(map1, map2);

impl<K, V, const N: usize> From<[(K, V); N]> for HashMap<K, V, RandomState> where
    K: Eq + Hash, 

fn from(arr: [(K, V); N]) -> Self

Examples

use std::collections::HashMap;

let map1 = HashMap::from([(1, 2), (3, 4)]);
let map2: HashMap<_, _> = [(1, 2), (3, 4)].into();
assert_eq!(map1, map2);

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

pub fn from(array: [T; LANES]) -> Simd<T, LANES>

执行转换。

impl<T, const N: usize> From<[T; N]> for Box<[T], Global>

pub fn from(array: [T; N]) -> Box<[T], Global>

将 [T; N] 转换为 Box<[T]>

此转换将数组移动到新的堆分配的内存中。

Examples

let boxed: Box<[u8]> = Box::from([4, 2]);
println!("{:?}", boxed);

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

pub fn from(arr: [T; N]) -> BTreeSet<T>

use std::collections::BTreeSet;

let set1 = BTreeSet::from([1, 2, 3, 4]);
let set2: BTreeSet<_> = [1, 2, 3, 4].into();
assert_eq!(set1, set2);

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

pub fn from(arr: [T; N]) -> BinaryHeap<T>

use std::collections::BinaryHeap;

let mut h1 = BinaryHeap::from([1, 4, 2, 3]);
let mut h2: BinaryHeap<_> = [1, 4, 2, 3].into();
while let Some((a, b)) = h1.pop().zip(h2.pop()) {
    assert_eq!(a, b);
}

impl<T, const N: usize> From<[T; N]> for Vec<T, Global>

pub fn from(s: [T; N]) -> Vec<T, Global>

执行转换。

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

pub fn from(arr: [T; N]) -> LinkedList<T>

use std::collections::LinkedList;

let list1 = LinkedList::from([1, 2, 3, 4]);
let list2: LinkedList<_> = [1, 2, 3, 4].into();
assert_eq!(list1, list2);

impl<T, const N: usize> From<[T; N]> for VecDeque<T, Global>

pub fn from(arr: [T; N]) -> VecDeque<T, Global>

use std::collections::VecDeque;

let deq1 = VecDeque::from([1, 2, 3, 4]);
let deq2: VecDeque<_> = [1, 2, 3, 4].into();
assert_eq!(deq1, deq2);

impl<T, const N: usize> From<[T; N]> for HashSet<T, RandomState> where
    T: Eq + Hash, 

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

Examples

use std::collections::HashSet;

let set1 = HashSet::from([1, 2, 3, 4]);
let set2: HashSet<_> = [1, 2, 3, 4].into();
assert_eq!(set1, set2);

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

pub fn from(array: [bool; LANES]) -> Mask<T, LANES>

执行转换。

impl From<[u16; 8]> for Ipv6Addr

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
);

impl From<[u16; 8]> for IpAddr

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
);

impl From<[u8; 16]> for Ipv6Addr

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
);

impl From<[u8; 16]> for IpAddr

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
);

impl From<[u8; 4]> for Ipv4Addr

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);

impl From<[u8; 4]> for IpAddr

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);

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

pub fn from(vector: Mask<T, LANES>) -> [bool; LANES]

执行转换。

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

pub fn from(vector: Simd<T, LANES>) -> [T; LANES]

执行转换。

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

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

#![feature(build_hasher_simple_hash_one)]
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));

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

将该值输入给定的 Hasher。

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

将这种类型的切片送入给定的 Hasher 中。

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

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

索引后返回的类型。

pub fn index(&self, index: I) -> &<[T; N] as Index<I>>::Output

执行索引 (container[index]) 操作。

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

pub fn index_mut(&mut self, index: I) -> &mut <[T; N] as Index<I>>::Output

执行可变索引 (container[index]) 操作。

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

type Item = &'a mut T

被迭代的元素的类型。

type IntoIter = IterMut<'a, T>

我们将其变成哪种迭代器？

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

从一个值创建一个迭代器。

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

pub fn into_iter(self) -> <[T; N] as IntoIterator>::IntoIter

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

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

type Item = T

被迭代的元素的类型。

type IntoIter = IntoIter<T, N>

我们将其变成哪种迭代器？

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

type Item = &'a T

被迭代的元素的类型。

type IntoIter = Iter<'a, T>

我们将其变成哪种迭代器？

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

从一个值创建一个迭代器。

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

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

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

此方法返回 self 和 other 之间的 Ordering。

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

比较并返回两个值中的最大值。

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

比较并返回两个值中的最小值。

fn clamp(self, min: Self, max: Self) -> Self

将值限制在某个时间间隔内。

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

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

此方法测试 self 和 other 值是否相等，并由 == 使用。

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

此方法测试 !=。

impl<'_, T, U, A, const N: usize> PartialEq<&'_ [U; N]> for VecDeque<T, A> where
    A: Allocator,
    T: PartialEq<U>, 

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

此方法测试 self 和 other 值是否相等，并由 == 使用。

fn ne(&self, other: &Rhs) -> bool

此方法测试 !=。

impl<'_, T, U, A, const N: usize> PartialEq<&'_ [U; N]> for Vec<T, A> where
    A: Allocator,
    T: PartialEq<U>, 

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

此方法测试 self 和 other 值是否相等，并由 == 使用。

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

此方法测试 !=。

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

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

此方法测试 self 和 other 值是否相等，并由 == 使用。

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

此方法测试 !=。

impl<'_, T, U, A, const N: usize> PartialEq<&'_ mut [U; N]> for VecDeque<T, A> where
    A: Allocator,
    T: PartialEq<U>, 

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

此方法测试 self 和 other 值是否相等，并由 == 使用。

fn ne(&self, other: &Rhs) -> bool

此方法测试 !=。

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

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

此方法测试 self 和 other 值是否相等，并由 == 使用。

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

此方法测试 !=。

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

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

此方法测试 self 和 other 值是否相等，并由 == 使用。

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

此方法测试 !=。

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

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

此方法测试 self 和 other 值是否相等，并由 == 使用。

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

此方法测试 !=。

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

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

此方法测试 self 和 other 值是否相等，并由 == 使用。

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

此方法测试 !=。

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

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

此方法测试 self 和 other 值是否相等，并由 == 使用。

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

此方法测试 !=。

impl<T, U, A, const N: usize> PartialEq<[U; N]> for VecDeque<T, A> where
    A: Allocator,
    T: PartialEq<U>, 

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

此方法测试 self 和 other 值是否相等，并由 == 使用。

fn ne(&self, other: &Rhs) -> bool

此方法测试 !=。

impl<T, U, A, const N: usize> PartialEq<[U; N]> for Vec<T, A> where
    A: Allocator,
    T: PartialEq<U>, 

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

此方法测试 self 和 other 值是否相等，并由 == 使用。

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

此方法测试 !=。

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

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

如果存在，则此方法返回 self 和 other 值之间的顺序。

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

此方法测试的内容少于 (对于 self 和 other)，并且由 < 操作员使用。

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

此方法测试小于或等于 (对于 self 和 other)，并且由 <= 运算符使用。

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

此方法测试是否大于或等于 (对于 self 和 other)，并且由 >= 运算符使用。

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

此方法测试大于 (对于 self 和 other)，并且由 > 操作员使用。

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

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

Examples

assert_eq!("Hello world".find(['l', 'l']), Some(2));
assert_eq!("Hello world".find(['l', 'l']), Some(2));

type Searcher = CharArraySearcher<'a, N>

🔬 This is a nightly-only experimental API. (pattern #27721)

此模式的关联搜索者

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

🔬 This is a nightly-only experimental API. (pattern #27721)

从 self 和 haystack 构造关联的搜索器以进行搜索。

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

🔬 This is a nightly-only experimental API. (pattern #27721)

检查模式是否与 haystack 中的任何位置匹配

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

🔬 This is a nightly-only experimental API. (pattern #27721)

检查模式是否在 haystack 的前面匹配

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

🔬 This is a nightly-only experimental API. (pattern #27721)

如果匹配，则从 haystack 的正面删除模式。

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

🔬 This is a nightly-only experimental API. (pattern #27721)

检查模式是否与 haystack 的后面匹配

pub 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 的后面删除模式。

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

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

Examples

assert_eq!("Hello world".find(&['l', 'l']), Some(2));
assert_eq!("Hello world".find(&['l', 'l']), Some(2));

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

🔬 This is a nightly-only experimental API. (pattern #27721)

此模式的关联搜索者

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

🔬 This is a nightly-only experimental API. (pattern #27721)

从 self 和 haystack 构造关联的搜索器以进行搜索。

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

🔬 This is a nightly-only experimental API. (pattern #27721)

检查模式是否与 haystack 中的任何位置匹配

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

🔬 This is a nightly-only experimental API. (pattern #27721)

检查模式是否在 haystack 的前面匹配

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

🔬 This is a nightly-only experimental API. (pattern #27721)

如果匹配，则从 haystack 的正面删除模式。

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

🔬 This is a nightly-only experimental API. (pattern #27721)

检查模式是否与 haystack 的后面匹配

pub 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 的后面删除模式。

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

type Item = T

🔬 This is a nightly-only experimental API. (slice_pattern #56345)

匹配的切片的元素类型。

pub fn as_slice(&self) -> &[<[T; N] as SlicePattern>::Item]

🔬 This is a nightly-only experimental API. (slice_pattern #56345)

当前，SlicePattern 的消费者需要切片。

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

type Error = TryFromSliceError

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

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

执行转换。

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

type Error = TryFromSliceError

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

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

执行转换。

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

type Error = TryFromSliceError

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

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

执行转换。

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

type Error = TryFromSliceError

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

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

执行转换。

impl<T, A, const N: usize> TryFrom<Vec<T, A>> for [T; N] where
    A: Allocator, 

pub fn try_from(vec: Vec<T, A>) -> Result<[T; N], Vec<T, A>>

如果 Vec<T> 的大小与请求的数组的大小完全匹配，则以数组的形式获取 Vec<T> 的全部内容。

Examples

use std::convert::TryInto;
assert_eq!(vec![1, 2, 3].try_into(), Ok([1, 2, 3]));
assert_eq!(<Vec<i32>>::new().try_into(), Ok([]));

如果长度不匹配，则输入以 Err 返回：

use std::convert::TryInto;
let r: Result<[i32; 4], _> = (0..10).collect::<Vec<_>>().try_into();
assert_eq!(r, Err(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9]));

如果只需要获得 Vec<T> 的前缀就可以了，您可以先调用 .truncate(N)。

use std::convert::TryInto;
let mut v = String::from("hello world").into_bytes();
v.sort();
v.truncate(2);
let [a, b]: [_; 2] = v.try_into().unwrap();
assert_eq!(a, b' ');
assert_eq!(b, b'd');

type Error = Vec<T, A>

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

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

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