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();
RunEditions
在 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}");
}
RunImplementations§
source§impl<T, const N: usize> [MaybeUninit<T>; N]
impl<T, const N: usize> [MaybeUninit<T>; N]
sourcepub const fn transpose(self) -> MaybeUninit<[T; N]>
🔬This is a nightly-only experimental API. (maybe_uninit_uninit_array_transpose
#96097)
pub const fn transpose(self) -> MaybeUninit<[T; N]>
maybe_uninit_uninit_array_transpose
#96097)source§impl<const N: usize> [u8; N]
impl<const N: usize> [u8; N]
source§impl<T, const N: usize> [T; N]
impl<T, const N: usize> [T; N]
1.55.0 · sourcepub fn map<F, U>(self, f: F) -> [U; N]where
F: FnMut(T) -> U,
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]);
Runsourcepub 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)
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]>,
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));
Runsourcepub fn zip<U>(self, rhs: [U; N]) -> [(T, U); N]
🔬This is a nightly-only experimental API. (array_zip
#80094)
pub fn zip<U>(self, rhs: [U; N]) -> [(T, U); N]
array_zip
#80094)1.57.0 · sourcepub fn as_mut_slice(&mut self) -> &mut [T]
pub fn as_mut_slice(&mut self) -> &mut [T]
返回包含整个数组的可变切片。
等效于 &mut s[..]
。
sourcepub fn each_ref(&self) -> [&T; N]
🔬This is a nightly-only experimental API. (array_methods
#76118)
pub fn each_ref(&self) -> [&T; N]
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);
Runsourcepub fn each_mut(&mut self) -> [&mut T; N]
🔬This is a nightly-only experimental API. (array_methods
#76118)
pub fn each_mut(&mut self) -> [&mut T; N]
array_methods
#76118)sourcepub fn split_array_ref<const M: usize>(&self) -> (&[T; M], &[T])
🔬This is a nightly-only experimental API. (split_array
#90091)
pub fn split_array_ref<const M: usize>(&self) -> (&[T; M], &[T])
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, &[]);
}
Runsourcepub fn split_array_mut<const M: usize>(&mut self) -> (&mut [T; M], &mut [T])
🔬This is a nightly-only experimental API. (split_array
#90091)
pub fn split_array_mut<const M: usize>(&mut self) -> (&mut [T; M], &mut [T])
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]);
Runsourcepub fn rsplit_array_ref<const M: usize>(&self) -> (&[T], &[T; M])
🔬This is a nightly-only experimental API. (split_array
#90091)
pub fn rsplit_array_ref<const M: usize>(&self) -> (&[T], &[T; M])
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]);
}
Runsourcepub fn rsplit_array_mut<const M: usize>(&mut self) -> (&mut [T], &mut [T; M])
🔬This is a nightly-only experimental API. (split_array
#90091)
pub fn rsplit_array_mut<const M: usize>(&mut self) -> (&mut [T], &mut [T; M])
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]);
RunTrait Implementations§
source§impl<T, const N: usize> AsMut<[T; N]> for Simd<T, N>where
LaneCount<N>: SupportedLaneCount,
T: SimdElement,
impl<T, const N: usize> AsMut<[T; N]> for Simd<T, N>where LaneCount<N>: SupportedLaneCount, T: SimdElement,
source§impl<T, const N: usize> AsRef<[T; N]> for Simd<T, N>where
LaneCount<N>: SupportedLaneCount,
T: SimdElement,
impl<T, const N: usize> AsRef<[T; N]> for Simd<T, N>where LaneCount<N>: SupportedLaneCount, T: SimdElement,
1.4.0 · source§impl<T, const N: usize> BorrowMut<[T]> for [T; N]
impl<T, const N: usize> BorrowMut<[T]> for [T; N]
source§fn borrow_mut(&mut self) -> &mut [T]
fn borrow_mut(&mut self) -> &mut [T]
1.71.0 · source§impl<T> From<[T; 10]> for (T, T, T, T, T, T, T, T, T, T)
impl<T> From<[T; 10]> for (T, T, T, T, T, T, T, T, T, T)
1.71.0 · source§impl<T> From<[T; 11]> for (T, T, T, T, T, T, T, T, T, T, T)
impl<T> From<[T; 11]> for (T, T, T, T, T, T, T, T, T, T, T)
1.71.0 · source§impl<T> From<[T; 12]> for (T, T, T, T, T, T, T, T, T, T, T, T)
impl<T> From<[T; 12]> for (T, T, T, T, T, T, T, T, T, T, T, T)
1.71.0 · source§impl<T> From<[T; 4]> for (T, T, T, T)
impl<T> From<[T; 4]> for (T, T, T, T)
1.71.0 · source§impl<T> From<[T; 5]> for (T, T, T, T, T)
impl<T> From<[T; 5]> for (T, T, T, T, T)
1.71.0 · source§impl<T> From<[T; 6]> for (T, T, T, T, T, T)
impl<T> From<[T; 6]> for (T, T, T, T, T, T)
1.71.0 · source§impl<T> From<[T; 7]> for (T, T, T, T, T, T, T)
impl<T> From<[T; 7]> for (T, T, T, T, T, T, T)
1.71.0 · source§impl<T> From<[T; 8]> for (T, T, T, T, T, T, T, T)
impl<T> From<[T; 8]> for (T, T, T, T, T, T, T, T)
1.71.0 · source§impl<T> From<[T; 9]> for (T, T, T, T, T, T, T, T, T)
impl<T> From<[T; 9]> for (T, T, T, T, T, T, T, T, T)
source§impl<T, const N: usize> From<[T; N]> for Simd<T, N>where
LaneCount<N>: SupportedLaneCount,
T: SimdElement,
impl<T, const N: usize> From<[T; N]> for Simd<T, N>where LaneCount<N>: SupportedLaneCount, T: SimdElement,
source§impl<T, const LANES: usize> From<[bool; LANES]> for Mask<T, LANES>where
T: MaskElement,
LaneCount<LANES>: SupportedLaneCount,
impl<T, const LANES: usize> From<[bool; LANES]> for Mask<T, LANES>where T: MaskElement, LaneCount<LANES>: SupportedLaneCount,
1.17.0 · source§impl From<[u8; 16]> for IpAddr
impl From<[u8; 16]> for IpAddr
source§fn from(octets: [u8; 16]) -> 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
);
Run1.71.0 · source§impl<T> From<(T, T, T, T)> for [T; 4]
impl<T> From<(T, T, T, T)> for [T; 4]
source§fn from(tuple: (T, T, T, T)) -> Self
fn from(tuple: (T, T, T, T)) -> Self
1.71.0 · source§impl<T> From<(T, T, T, T, T)> for [T; 5]
impl<T> From<(T, T, T, T, T)> for [T; 5]
source§fn from(tuple: (T, T, T, T, T)) -> Self
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]
impl<T> From<(T, T, T, T, T, T)> for [T; 6]
source§fn from(tuple: (T, T, T, T, T, T)) -> Self
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]
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
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]
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
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]
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
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]
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
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]
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
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]
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
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,
impl<T, const LANES: usize> From<Mask<T, LANES>> for [bool; LANES]where T: MaskElement, LaneCount<LANES>: SupportedLaneCount,
source§impl<T, const N: usize> From<Simd<T, N>> for [T; N]where
LaneCount<N>: SupportedLaneCount,
T: SimdElement,
impl<T, const N: usize> From<Simd<T, N>> for [T; N]where LaneCount<N>: SupportedLaneCount, T: SimdElement,
source§impl<T: Hash, const N: usize> Hash for [T; N]
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));
Runsource§impl<'a, T, const N: usize> IntoIterator for &'a [T; N]
impl<'a, T, const N: usize> IntoIterator for &'a [T; N]
source§impl<'a, T, const N: usize> IntoIterator for &'a mut [T; N]
impl<'a, T, const N: usize> IntoIterator for &'a mut [T; N]
1.53.0 · source§impl<T, const N: usize> IntoIterator for [T; N]
impl<T, const N: usize> IntoIterator for [T; N]
source§impl<T: PartialOrd, const N: usize> PartialOrd<[T; N]> for [T; N]
impl<T: PartialOrd, const N: usize> PartialOrd<[T; N]> for [T; N]
source§impl<'a, 'b, const N: usize> Pattern<'a> for &'b [char; N]
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>
type Searcher = CharArrayRefSearcher<'a, 'b, N>
pattern
#27721)source§fn into_searcher(self, haystack: &'a str) -> CharArrayRefSearcher<'a, 'b, N>
fn into_searcher(self, haystack: &'a str) -> CharArrayRefSearcher<'a, 'b, N>
pattern
#27721)self
和 haystack
构造关联的搜索器以进行搜索。source§fn is_contained_in(self, haystack: &'a str) -> bool
fn is_contained_in(self, haystack: &'a str) -> bool
pattern
#27721)source§fn is_prefix_of(self, haystack: &'a str) -> bool
fn is_prefix_of(self, haystack: &'a str) -> bool
pattern
#27721)source§fn strip_prefix_of(self, haystack: &'a str) -> Option<&'a str>
fn strip_prefix_of(self, haystack: &'a str) -> Option<&'a str>
pattern
#27721)source§fn is_suffix_of(self, haystack: &'a str) -> boolwhere
CharArrayRefSearcher<'a, 'b, N>: ReverseSearcher<'a>,
fn is_suffix_of(self, haystack: &'a str) -> boolwhere CharArrayRefSearcher<'a, 'b, N>: ReverseSearcher<'a>,
pattern
#27721)source§fn strip_suffix_of(self, haystack: &'a str) -> Option<&'a str>where
CharArrayRefSearcher<'a, 'b, N>: ReverseSearcher<'a>,
fn strip_suffix_of(self, haystack: &'a str) -> Option<&'a str>where CharArrayRefSearcher<'a, 'b, N>: ReverseSearcher<'a>,
pattern
#27721)source§impl<'a, const N: usize> Pattern<'a> for [char; N]
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>
type Searcher = CharArraySearcher<'a, N>
pattern
#27721)source§fn into_searcher(self, haystack: &'a str) -> CharArraySearcher<'a, N>
fn into_searcher(self, haystack: &'a str) -> CharArraySearcher<'a, N>
pattern
#27721)self
和 haystack
构造关联的搜索器以进行搜索。source§fn is_contained_in(self, haystack: &'a str) -> bool
fn is_contained_in(self, haystack: &'a str) -> bool
pattern
#27721)source§fn is_prefix_of(self, haystack: &'a str) -> bool
fn is_prefix_of(self, haystack: &'a str) -> bool
pattern
#27721)source§fn strip_prefix_of(self, haystack: &'a str) -> Option<&'a str>
fn strip_prefix_of(self, haystack: &'a str) -> Option<&'a str>
pattern
#27721)source§fn is_suffix_of(self, haystack: &'a str) -> boolwhere
CharArraySearcher<'a, N>: ReverseSearcher<'a>,
fn is_suffix_of(self, haystack: &'a str) -> boolwhere CharArraySearcher<'a, N>: ReverseSearcher<'a>,
pattern
#27721)source§fn strip_suffix_of(self, haystack: &'a str) -> Option<&'a str>where
CharArraySearcher<'a, N>: ReverseSearcher<'a>,
fn strip_suffix_of(self, haystack: &'a str) -> Option<&'a str>where CharArraySearcher<'a, N>: ReverseSearcher<'a>,
pattern
#27721)1.51.0 · source§impl<T, const N: usize> SlicePattern for [T; N]
impl<T, const N: usize> SlicePattern for [T; N]
1.34.0 · source§impl<T, const N: usize> TryFrom<&[T]> for [T; N]where
T: Copy,
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
type Error = TryFromSliceError
1.34.0 · source§impl<'a, T, const N: usize> TryFrom<&'a [T]> for &'a [T; N]
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
type Error = TryFromSliceError
1.34.0 · source§impl<'a, T, const N: usize> TryFrom<&'a mut [T]> for &'a mut [T; N]
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
type Error = TryFromSliceError
1.59.0 · source§impl<T, const N: usize> TryFrom<&mut [T]> for [T; N]where
T: Copy,
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