Primitive Type slice

一个动态大小的视图到一个连续的序列，[T]。 这里的连续意味着元素的布局应使每个元素与其相邻元素之间的距离相同。

See also the std::slice module.

切片是一个内存块的视图，表示为一个指针和一个长度。

// 切片 Vec
let vec = vec![1, 2, 3];
let int_slice = &vec[..];
// 将数组强制转换为切片
let str_slice: &[&str] = &["one", "two", "three"];

切片是可变的或共享的。 共享切片类型为 &[T]，而可变切片类型为 &mut [T]，其中 T 表示元素类型。 例如，您可以更改可变切片所指向的内存块：

let mut x = [1, 2, 3];
let x = &mut x[..]; // 取 `x` 的完整切片。
x[1] = 7;
assert_eq!(x, &[1, 7, 3]);

当切片存储所引用序列的长度时，它们的指针大小是 Sized 类型的两倍。 另请参见 动态大小的类型 上的引用。

let pointer_size = std::mem::size_of::<&u8>();
assert_eq!(2 * pointer_size, std::mem::size_of::<&[u8]>());
assert_eq!(2 * pointer_size, std::mem::size_of::<*const [u8]>());
assert_eq!(2 * pointer_size, std::mem::size_of::<Box<[u8]>>());
assert_eq!(2 * pointer_size, std::mem::size_of::<Rc<[u8]>>());

Trait 实现

如果元素类型实现了 trait，则为切片实现了一些 traits。这包括 Eq、Hash 和 Ord。

Iteration

切片实现 IntoIterator。迭代器产生对切片元素的引用。

let numbers: &[i32] = &[0, 1, 2];
for n in numbers {
    println!("{n} is a number!");
}

可变切片对以下元素产生了可变引用：

let mut scores: &mut [i32] = &mut [7, 8, 9];
for score in scores {
    *score += 1;
}

此迭代器产生对切片元素的可变引用，因此，当切片的元素类型为 i32 时，迭代器的元素类型为 &mut i32。

• .iter 和 .iter_mut 是返回默认迭代器的显式方法。
• 返回迭代器的其他方法是 .split，.splitn，.chunks，.windows 等。

Implementations

impl<T> Box<[T], Global>

pub fn new_uninit_slice(len: usize) -> Box<[MaybeUninit<T>], Global>

🔬This is a nightly-only experimental API. (new_uninit #63291)

创建一个具有未初始化内容的新 boxed 切片。

Examples

#![feature(new_uninit)]

let mut values = Box::<[u32]>::new_uninit_slice(3);

let values = unsafe {
    // 延迟初始化：
    values[0].as_mut_ptr().write(1);
    values[1].as_mut_ptr().write(2);
    values[2].as_mut_ptr().write(3);

    values.assume_init()
};

assert_eq!(*values, [1, 2, 3])

pub fn new_zeroed_slice(len: usize) -> Box<[MaybeUninit<T>], Global>

🔬This is a nightly-only experimental API. (new_uninit #63291)

创建一个具有未初始化内容的新 boxed 切片，并用 0 字节填充内存。

有关正确和不正确使用此方法的示例，请参见 MaybeUninit::zeroed。

Examples

#![feature(new_uninit)]

let values = Box::<[u32]>::new_zeroed_slice(3);
let values = unsafe { values.assume_init() };

assert_eq!(*values, [0, 0, 0])

pub fn try_new_uninit_slice( len: usize ) -> Result<Box<[MaybeUninit<T>], Global>, AllocError>

🔬This is a nightly-only experimental API. (allocator_api #32838)

创建一个具有未初始化内容的新 boxed 切片。 如果分配失败，则返回一个错误

Examples

#![feature(allocator_api, new_uninit)]

let mut values = Box::<[u32]>::try_new_uninit_slice(3)?;
let values = unsafe {
    // 延迟初始化：
    values[0].as_mut_ptr().write(1);
    values[1].as_mut_ptr().write(2);
    values[2].as_mut_ptr().write(3);
    values.assume_init()
};

assert_eq!(*values, [1, 2, 3]);

pub fn try_new_zeroed_slice( len: usize ) -> Result<Box<[MaybeUninit<T>], Global>, AllocError>

🔬This is a nightly-only experimental API. (allocator_api #32838)

创建一个具有未初始化内容的新 boxed 切片，并用 0 字节填充内存。 如果分配失败，则返回一个错误

有关正确和不正确使用此方法的示例，请参见 MaybeUninit::zeroed。

Examples

#![feature(allocator_api, new_uninit)]

let values = Box::<[u32]>::try_new_zeroed_slice(3)?;
let values = unsafe { values.assume_init() };

assert_eq!(*values, [0, 0, 0]);

impl<T, A> Box<[T], A>where A: Allocator,

pub fn new_uninit_slice_in(len: usize, alloc: A) -> Box<[MaybeUninit<T>], A>

🔬This is a nightly-only experimental API. (allocator_api #32838)

使用提供的分配器中未初始化的内容创建一个新的 boxed 切片。

Examples

#![feature(allocator_api, new_uninit)]

use std::alloc::System;

let mut values = Box::<[u32], _>::new_uninit_slice_in(3, System);

let values = unsafe {
    // 延迟初始化：
    values[0].as_mut_ptr().write(1);
    values[1].as_mut_ptr().write(2);
    values[2].as_mut_ptr().write(3);

    values.assume_init()
};

assert_eq!(*values, [1, 2, 3])

pub fn new_zeroed_slice_in(len: usize, alloc: A) -> Box<[MaybeUninit<T>], A>

🔬This is a nightly-only experimental API. (allocator_api #32838)

使用提供的分配器中未初始化的内容创建一个新的 boxed 切片，并用 0 字节填充内存。

有关正确和不正确使用此方法的示例，请参见 MaybeUninit::zeroed。

Examples

#![feature(allocator_api, new_uninit)]

use std::alloc::System;

let values = Box::<[u32], _>::new_zeroed_slice_in(3, System);
let values = unsafe { values.assume_init() };

assert_eq!(*values, [0, 0, 0])

impl<T, A> Box<[MaybeUninit<T>], A>where A: Allocator,

pub unsafe fn assume_init(self) -> Box<[T], A>

🔬This is a nightly-only experimental API. (new_uninit #63291)

转换为 Box<[T], A>。

Safety

与 MaybeUninit::assume_init 一样，由调用者负责确保值确实处于初始化状态。

在内容尚未完全初始化时调用此方法会立即导致未定义的行为。

Examples

#![feature(new_uninit)]

let mut values = Box::<[u32]>::new_uninit_slice(3);

let values = unsafe {
    // 延迟初始化：
    values[0].as_mut_ptr().write(1);
    values[1].as_mut_ptr().write(2);
    values[2].as_mut_ptr().write(3);

    values.assume_init()
};

assert_eq!(*values, [1, 2, 3])

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

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

🔬This is a nightly-only experimental API. (slice_flatten #95629)

取 &[[T; N]]，并将其展平为 &[T]。

Panics

如果结果切片的长度会溢出 usize，则会出现 panic。

这仅在展平零大小类型的数组切片时才有可能，因此在实践中往往无关紧要。 如果是 size_of::<T>() > 0，这将永远不会 panic。

Examples

#![feature(slice_flatten)]

assert_eq!([[1, 2, 3], [4, 5, 6]].flatten(), &[1, 2, 3, 4, 5, 6]);

assert_eq!(
    [[1, 2, 3], [4, 5, 6]].flatten(),
    [[1, 2], [3, 4], [5, 6]].flatten(),
);

let slice_of_empty_arrays: &[[i32; 0]] = &[[], [], [], [], []];
assert!(slice_of_empty_arrays.flatten().is_empty());

let empty_slice_of_arrays: &[[u32; 10]] = &[];
assert!(empty_slice_of_arrays.flatten().is_empty());

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

🔬This is a nightly-only experimental API. (slice_flatten #95629)

取 &mut [[T; N]]，并将其展平为 &mut [T]。

Panics

如果结果切片的长度会溢出 usize，则会出现 panic。

这仅在展平零大小类型的数组切片时才有可能，因此在实践中往往无关紧要。 如果是 size_of::<T>() > 0，这将永远不会 panic。

Examples

#![feature(slice_flatten)]

fn add_5_to_all(slice: &mut [i32]) {
    for i in slice {
        *i += 5;
    }
}

let mut array = [[1, 2, 3], [4, 5, 6], [7, 8, 9]];
add_5_to_all(array.flatten_mut());
assert_eq!(array, [[6, 7, 8], [9, 10, 11], [12, 13, 14]]);

impl<T> [T]

pub const fn len(&self) -> usize

返回切片中的元素数。

Examples

let a = [1, 2, 3];
assert_eq!(a.len(), 3);

pub const fn is_empty(&self) -> bool

如果切片的长度为，则返回 true 0.

Examples

let a = [1, 2, 3];
assert!(!a.is_empty());

pub const fn first(&self) -> Option<&T>

返回切片的第一个元素; 如果为空，则返回 None。

Examples

let v = [10, 40, 30];
assert_eq!(Some(&10), v.first());

let w: &[i32] = &[];
assert_eq!(None, w.first());

pub fn first_mut(&mut self) -> Option<&mut T>

返回指向切片第一个元素的可变指针，如果为空则返回 None。

Examples

let x = &mut [0, 1, 2];

if let Some(first) = x.first_mut() {
    *first = 5;
}
assert_eq!(x, &[5, 1, 2]);

pub const fn split_first(&self) -> Option<(&T, &[T])>

返回切片的第一个元素和所有其他元素，如果为空，则返回 None。

Examples

let x = &[0, 1, 2];

if let Some((first, elements)) = x.split_first() {
    assert_eq!(first, &0);
    assert_eq!(elements, &[1, 2]);
}

pub fn split_first_mut(&mut self) -> Option<(&mut T, &mut [T])>

返回切片的第一个元素和所有其他元素，如果为空，则返回 None。

Examples

let x = &mut [0, 1, 2];

if let Some((first, elements)) = x.split_first_mut() {
    *first = 3;
    elements[0] = 4;
    elements[1] = 5;
}
assert_eq!(x, &[3, 4, 5]);

pub const fn split_last(&self) -> Option<(&T, &[T])>

返回切片的最后一个元素和所有其他元素，如果为空，则返回 None。

Examples

let x = &[0, 1, 2];

if let Some((last, elements)) = x.split_last() {
    assert_eq!(last, &2);
    assert_eq!(elements, &[0, 1]);
}

pub fn split_last_mut(&mut self) -> Option<(&mut T, &mut [T])>

返回切片的最后一个元素和所有其他元素，如果为空，则返回 None。

Examples

let x = &mut [0, 1, 2];

if let Some((last, elements)) = x.split_last_mut() {
    *last = 3;
    elements[0] = 4;
    elements[1] = 5;
}
assert_eq!(x, &[4, 5, 3]);

pub const fn last(&self) -> Option<&T>

返回切片的最后一个元素; 如果为空，则返回 None。

Examples

let v = [10, 40, 30];
assert_eq!(Some(&30), v.last());

let w: &[i32] = &[];
assert_eq!(None, w.last());

pub fn last_mut(&mut self) -> Option<&mut T>

返回指向切片中最后一个项的可变指针。

Examples

let x = &mut [0, 1, 2];

if let Some(last) = x.last_mut() {
    *last = 10;
}
assert_eq!(x, &[0, 1, 10]);

pub fn first_chunk<const N: usize>(&self) -> Option<&[T; N]>

🔬This is a nightly-only experimental API. (slice_first_last_chunk #111774)

返回切片的第一个 N 元素，如果元素少于 N，则返回 None。

Examples

#![feature(slice_first_last_chunk)]

let u = [10, 40, 30];
assert_eq!(Some(&[10, 40]), u.first_chunk::<2>());

let v: &[i32] = &[10];
assert_eq!(None, v.first_chunk::<2>());

let w: &[i32] = &[];
assert_eq!(Some(&[]), w.first_chunk::<0>());

pub fn first_chunk_mut<const N: usize>(&mut self) -> Option<&mut [T; N]>

🔬This is a nightly-only experimental API. (slice_first_last_chunk #111774)

返回切片的第一个 N 元素的可变引用，如果它的元素少于 N，则返回 None。

Examples

#![feature(slice_first_last_chunk)]

let x = &mut [0, 1, 2];

if let Some(first) = x.first_chunk_mut::<2>() {
    first[0] = 5;
    first[1] = 4;
}
assert_eq!(x, &[5, 4, 2]);

pub fn split_first_chunk<const N: usize>(&self) -> Option<(&[T; N], &[T])>

🔬This is a nightly-only experimental API. (slice_first_last_chunk #111774)

返回切片的第一个 N 元素和其余元素，如果元素少于 N，则返回 None。

Examples

#![feature(slice_first_last_chunk)]

let x = &[0, 1, 2];

if let Some((first, elements)) = x.split_first_chunk::<2>() {
    assert_eq!(first, &[0, 1]);
    assert_eq!(elements, &[2]);
}

pub fn split_first_chunk_mut<const N: usize>( &mut self ) -> Option<(&mut [T; N], &mut [T])>

🔬This is a nightly-only experimental API. (slice_first_last_chunk #111774)

返回切片的第一个 N 元素和其余元素的可变引用，如果元素少于 N，则返回 None。

Examples

#![feature(slice_first_last_chunk)]

let x = &mut [0, 1, 2];

if let Some((first, elements)) = x.split_first_chunk_mut::<2>() {
    first[0] = 3;
    first[1] = 4;
    elements[0] = 5;
}
assert_eq!(x, &[3, 4, 5]);

pub fn split_last_chunk<const N: usize>(&self) -> Option<(&[T; N], &[T])>

🔬This is a nightly-only experimental API. (slice_first_last_chunk #111774)

返回切片的最后一个 N 元素和余数，如果元素少于 N，则返回 None。

Examples

#![feature(slice_first_last_chunk)]

let x = &[0, 1, 2];

if let Some((last, elements)) = x.split_last_chunk::<2>() {
    assert_eq!(last, &[1, 2]);
    assert_eq!(elements, &[0]);
}

pub fn split_last_chunk_mut<const N: usize>( &mut self ) -> Option<(&mut [T; N], &mut [T])>

🔬This is a nightly-only experimental API. (slice_first_last_chunk #111774)

返回切片的最后一个元素和所有其他元素，如果为空，则返回 None。

Examples

#![feature(slice_first_last_chunk)]

let x = &mut [0, 1, 2];

if let Some((last, elements)) = x.split_last_chunk_mut::<2>() {
    last[0] = 3;
    last[1] = 4;
    elements[0] = 5;
}
assert_eq!(x, &[5, 3, 4]);

pub fn last_chunk<const N: usize>(&self) -> Option<&[T; N]>

🔬This is a nightly-only experimental API. (slice_first_last_chunk #111774)

返回切片的最后一个元素; 如果为空，则返回 None。

Examples

#![feature(slice_first_last_chunk)]

let u = [10, 40, 30];
assert_eq!(Some(&[40, 30]), u.last_chunk::<2>());

let v: &[i32] = &[10];
assert_eq!(None, v.last_chunk::<2>());

let w: &[i32] = &[];
assert_eq!(Some(&[]), w.last_chunk::<0>());

pub fn last_chunk_mut<const N: usize>(&mut self) -> Option<&mut [T; N]>

🔬This is a nightly-only experimental API. (slice_first_last_chunk #111774)

返回指向切片中最后一个项的可变指针。

Examples

#![feature(slice_first_last_chunk)]

let x = &mut [0, 1, 2];

if let Some(last) = x.last_chunk_mut::<2>() {
    last[0] = 10;
    last[1] = 20;
}
assert_eq!(x, &[0, 10, 20]);

pub fn get<I>(&self, index: I) -> Option<&<I as SliceIndex<[T]>>::Output>where I: SliceIndex<[T]>,

根据索引的类型返回对元素或子切片的引用。

• 如果给定位置，则返回该位置上的元素的引用，如果越界则返回 None。

• 如果给定范围，则返回对应于该范围的子切片; 如果越界，则返回 None。

Examples

let v = [10, 40, 30];
assert_eq!(Some(&40), v.get(1));
assert_eq!(Some(&[10, 40][..]), v.get(0..2));
assert_eq!(None, v.get(3));
assert_eq!(None, v.get(0..4));

pub fn get_mut<I>( &mut self, index: I ) -> Option<&mut <I as SliceIndex<[T]>>::Output>where I: SliceIndex<[T]>,

根据索引的类型 (请参见 get) 或 None (如果索引越界)，对元素或子切片返回可变引用。

Examples

let x = &mut [0, 1, 2];

if let Some(elem) = x.get_mut(1) {
    *elem = 42;
}
assert_eq!(x, &[0, 42, 2]);

pub unsafe fn get_unchecked<I>( &self, index: I ) -> &<I as SliceIndex<[T]>>::Outputwhere I: SliceIndex<[T]>,

返回对元素或子切片的引用，而不进行边界检查。

有关安全的选择，请参见 get。

Safety

即使没有使用所得的引用，使用越界索引调用此方法也是 undefined behavior。

Examples

let x = &[1, 2, 4];

unsafe {
    assert_eq!(x.get_unchecked(1), &2);
}

pub unsafe fn get_unchecked_mut<I>( &mut self, index: I ) -> &mut <I as SliceIndex<[T]>>::Outputwhere I: SliceIndex<[T]>,

返回元素或子切片的可变引用，而不进行边界检查。

有关安全的选择，请参见 get_mut。

Safety

即使没有使用所得的引用，使用越界索引调用此方法也是 undefined behavior。

Examples

let x = &mut [1, 2, 4];

unsafe {
    let elem = x.get_unchecked_mut(1);
    *elem = 13;
}
assert_eq!(x, &[1, 13, 4]);

pub const fn as_ptr(&self) -> *const T

将裸指针返回到切片的缓冲区。

调用者必须确保切片比该函数返回的指针有效，否则它将最终指向垃圾。

调用者还必须确保指针 (non-transitively) 所指向的内存 (从 UnsafeCell 内部除外) 永远不会使用此指针或从其派生的任何指针写入。 如果需要更改切片的内容，请使用 as_mut_ptr。

修改此切片引用的容器可能会导致重新分配其缓冲区，这也将使指向它的任何指针无效。

Examples

let x = &[1, 2, 4];
let x_ptr = x.as_ptr();

unsafe {
    for i in 0..x.len() {
        assert_eq!(x.get_unchecked(i), &*x_ptr.add(i));
    }
}

pub const fn as_mut_ptr(&mut self) -> *mut T

返回指向切片缓冲区的不安全可变指针。

调用者必须确保切片比该函数返回的指针有效，否则它将最终指向垃圾。

修改此切片引用的容器可能会导致重新分配其缓冲区，这也将使指向它的任何指针无效。

Examples

let x = &mut [1, 2, 4];
let x_ptr = x.as_mut_ptr();

unsafe {
    for i in 0..x.len() {
        *x_ptr.add(i) += 2;
    }
}
assert_eq!(x, &[3, 4, 6]);

pub const fn as_ptr_range(&self) -> Range<*const T>

返回跨越切片的两个裸指针。

返回的范围是半开的，这意味着结束指针将 one 指向 切片的最后一个元素。 这样，一个空的切片由两个相等的指针表示，两个指针之间的差表示切片的大小。

有关使用这些指针的警告，请参见 as_ptr。结束指针需要格外小心，因为它没有指向切片中的有效元素。

此函数对于与外部接口进行交互很有用，该外部接口使用两个指针来引用内存中的一系列元素，这在 C++ 中很常见。

检查指向元素的指针是否引用了此切片的元素，这也可能很有用：

let a = [1, 2, 3];
let x = &a[1] as *const _;
let y = &5 as *const _;

assert!(a.as_ptr_range().contains(&x));
assert!(!a.as_ptr_range().contains(&y));

pub const fn as_mut_ptr_range(&mut self) -> Range<*mut T>

返回跨越切片的两个不安全的可变指针。

返回的范围是半开的，这意味着结束指针将 one 指向 切片的最后一个元素。 这样，一个空的切片由两个相等的指针表示，两个指针之间的差表示切片的大小。

有关使用这些指针的警告，请参见 as_mut_ptr。 结束指针需要格外小心，因为它没有指向切片中的有效元素。

此函数对于与外部接口进行交互很有用，该外部接口使用两个指针来引用内存中的一系列元素，这在 C++ 中很常见。

pub fn swap(&mut self, a: usize, b: usize)

在切片中交换两个元素。

Arguments

• a - 第一个元素的索引
• b - 第二个元素的索引

Panics

如果 a 或 b 越界，就会出现 panics。

Examples

let mut v = ["a", "b", "c", "d", "e"];
v.swap(2, 4);
assert!(v == ["a", "b", "e", "d", "c"]);

pub unsafe fn swap_unchecked(&mut self, a: usize, b: usize)

🔬This is a nightly-only experimental API. (slice_swap_unchecked #88539)

在不做边界检查的情况下交换切片中的两个元素。

有关安全的替代方案，请参见 swap。

Arguments

• a - 第一个元素的索引
• b - 第二个元素的索引

Safety

使用越界索引调用此方法是 未定义的行为。 调用者必须保证 a < self.len() 和 b < self.len()。

Examples

#![feature(slice_swap_unchecked)]

let mut v = ["a", "b", "c", "d"];
// SAFETY: 我们知道 1 和 3 都是切片的索引
unsafe { v.swap_unchecked(1, 3) };
assert!(v == ["a", "d", "c", "b"]);

pub fn reverse(&mut self)

适当地反转切片中元素的顺序。

Examples

let mut v = [1, 2, 3];
v.reverse();
assert!(v == [3, 2, 1]);

pub fn iter(&self) -> Iter<'_, T>

返回切片上的迭代器。

迭代器从头到尾产生所有项。

Examples

let x = &[1, 2, 4];
let mut iterator = x.iter();

assert_eq!(iterator.next(), Some(&1));
assert_eq!(iterator.next(), Some(&2));
assert_eq!(iterator.next(), Some(&4));
assert_eq!(iterator.next(), None);

pub fn iter_mut(&mut self) -> IterMut<'_, T>

返回允许修改每个值的迭代器。

迭代器从头到尾产生所有项。

Examples

let x = &mut [1, 2, 4];
for elem in x.iter_mut() {
    *elem += 2;
}
assert_eq!(x, &[3, 4, 6]);

pub fn windows(&self, size: usize) -> Windows<'_, T>

返回长度为 size 的所有连续 windows 上的迭代器。windows 重叠。如果切片短于 size，则迭代器不返回任何值。

Panics

panic 会发生在如果 size 是 0.

Examples

let slice = ['r', 'u', 's', 't'];
let mut iter = slice.windows(2);
assert_eq!(iter.next().unwrap(), &['r', 'u']);
assert_eq!(iter.next().unwrap(), &['u', 's']);
assert_eq!(iter.next().unwrap(), &['s', 't']);
assert!(iter.next().is_none());

如果切片短于 size：

let slice = ['f', 'o', 'o'];
let mut iter = slice.windows(4);
assert!(iter.next().is_none());

没有 windows_mut，因为现有的 windows_mut 会让安全代码违反 “only one &mut at a time to the same thing” 规则。 但是，您有时可以将 Cell::as_slice_of_cells 与 windows 结合使用来完成类似的事情:

use std::cell::Cell;

let mut array = ['R', 'u', 's', 't', ' ', '2', '0', '1', '5'];
let slice = &mut array[..];
let slice_of_cells: &[Cell<char>] = Cell::from_mut(slice).as_slice_of_cells();
for w in slice_of_cells.windows(3) {
    Cell::swap(&w[0], &w[2]);
}
assert_eq!(array, ['s', 't', ' ', '2', '0', '1', '5', 'u', 'R']);

pub fn chunks(&self, chunk_size: usize) -> Chunks<'_, T>

从切片的开头开始，一次返回对切片的 chunk_size 元素的迭代器。

块是切片，并且不重叠。如果 chunk_size 不划分切片的长度，则最后一块的长度将不为 chunk_size。

有关此迭代器的变体的信息，请参见 chunks_exact，它返回始终完全由 chunk_size 元素组成的块; 对于相同迭代器，请参见 rchunks，但均从切片的末尾开始。

Panics

panic 会发生在如果 chunk_size 是 0.

Examples

let slice = ['l', 'o', 'r', 'e', 'm'];
let mut iter = slice.chunks(2);
assert_eq!(iter.next().unwrap(), &['l', 'o']);
assert_eq!(iter.next().unwrap(), &['r', 'e']);
assert_eq!(iter.next().unwrap(), &['m']);
assert!(iter.next().is_none());

pub fn chunks_mut(&mut self, chunk_size: usize) -> ChunksMut<'_, T>

从切片的开头开始，一次返回对切片的 chunk_size 元素的迭代器。

块是可变切片，并且不重叠。如果 chunk_size 不划分切片的长度，则最后一块的长度将不为 chunk_size。

有关此迭代器的变体的信息，请参见 chunks_exact_mut，该变体返回始终完全相同的 chunk_size 元素的块; 对于相同的迭代器，请参见 rchunks_mut，但均从切片的末尾开始。

Panics

panic 会发生在如果 chunk_size 是 0.

Examples

let v = &mut [0, 0, 0, 0, 0];
let mut count = 1;

for chunk in v.chunks_mut(2) {
    for elem in chunk.iter_mut() {
        *elem += count;
    }
    count += 1;
}
assert_eq!(v, &[1, 1, 2, 2, 3]);

pub fn chunks_exact(&self, chunk_size: usize) -> ChunksExact<'_, T>

从切片的开头开始，一次返回对切片的 chunk_size 元素的迭代器。

块是切片，并且不重叠。 如果 chunk_size 不划分切片的长度，则最后 chunk_size-1 个元素将被省略，并可从迭代器的 remainder 函数中检索。

由于每个块都具有完全 chunk_size 元素，因此与 chunks 相比，编译器通常可以更好地优化结果代码。

请参见 chunks 以获取此迭代器的变体，该变体还以较小的块的形式返回其余部分，并以 rchunks_exact 获取相同的迭代器，但从切片的末尾开始。

Panics

panic 会发生在如果 chunk_size 是 0.

Examples

let slice = ['l', 'o', 'r', 'e', 'm'];
let mut iter = slice.chunks_exact(2);
assert_eq!(iter.next().unwrap(), &['l', 'o']);
assert_eq!(iter.next().unwrap(), &['r', 'e']);
assert!(iter.next().is_none());
assert_eq!(iter.remainder(), &['m']);

pub fn chunks_exact_mut(&mut self, chunk_size: usize) -> ChunksExactMut<'_, T>

从切片的开头开始，一次返回对切片的 chunk_size 元素的迭代器。

块是可变切片，并且不重叠。 如果 chunk_size 不划分切片的长度，则最后 chunk_size-1 个元素将被省略，并可从迭代器的 into_remainder 函数中检索。

由于每个块都具有完全 chunk_size 元素，因此与 chunks_mut 相比，编译器通常可以更好地优化结果代码。

请参见 chunks_mut 以获取此迭代器的变体，该变体还以较小的块的形式返回其余部分，并以 rchunks_exact_mut 获取相同的迭代器，但从切片的末尾开始。

Panics

panic 会发生在如果 chunk_size 是 0.

Examples

let v = &mut [0, 0, 0, 0, 0];
let mut count = 1;

for chunk in v.chunks_exact_mut(2) {
    for elem in chunk.iter_mut() {
        *elem += count;
    }
    count += 1;
}
assert_eq!(v, &[1, 1, 2, 2, 0]);

pub const unsafe fn as_chunks_unchecked<const N: usize>(&self) -> &[[T; N]]

🔬This is a nightly-only experimental API. (slice_as_chunks #74985)

假设没有余数，将切片拆分为 N 个元素数组的切片。

Safety

只能在以下情况下调用

• 切片精确地分为 N 个元素块 (也称为 self.len() % N == 0)。
• N != 0.

Examples

#![feature(slice_as_chunks)]
let slice: &[char] = &['l', 'o', 'r', 'e', 'm', '!'];
let chunks: &[[char; 1]] =
    // SAFETY: 1 个元素的块永远不会剩余
    unsafe { slice.as_chunks_unchecked() };
assert_eq!(chunks, &[['l'], ['o'], ['r'], ['e'], ['m'], ['!']]);
let chunks: &[[char; 3]] =
    // SAFETY: 切片长度 (6) 是 3 的倍数
    unsafe { slice.as_chunks_unchecked() };
assert_eq!(chunks, &[['l', 'o', 'r'], ['e', 'm', '!']]);

// 这些是不健全的：
// `let chunks: &[[_; 5]] = slice.as_chunks_unchecked()` // 切片长度不是 5 个的倍数: `let chunks: &[[_; 0]] = slice.as_chunks_unchecked()` // 永远不允许零长度的块

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

🔬This is a nightly-only experimental API. (slice_as_chunks #74985)

从切片的开头开始，将切片分成 N 个元素数组的切片，然后将其长度严格小于 N 的其余切片切成薄片。

Panics

如果 N 为 0，就会出现 panics。在此方法稳定之前，此检查很可能会更改为编译时错误。

Examples

#![feature(slice_as_chunks)]
let slice = ['l', 'o', 'r', 'e', 'm'];
let (chunks, remainder) = slice.as_chunks();
assert_eq!(chunks, &[['l', 'o'], ['r', 'e']]);
assert_eq!(remainder, &['m']);

如果您希望切片是一个精确的倍数，您可以将 let-else 与空切片模式结合使用:

#![feature(slice_as_chunks)]
let slice = ['R', 'u', 's', 't'];
let (chunks, []) = slice.as_chunks::<2>() else {
    panic!("slice didn't have even length")
};
assert_eq!(chunks, &[['R', 'u'], ['s', 't']]);

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

🔬This is a nightly-only experimental API. (slice_as_chunks #74985)

从切片的末尾开始，将切片分成 N 个元素数组的切片，然后将其长度严格小于 N 的其余切片切成薄片。

Panics

如果 N 为 0，就会出现 panics。在此方法稳定之前，此检查很可能会更改为编译时错误。

Examples

#![feature(slice_as_chunks)]
let slice = ['l', 'o', 'r', 'e', 'm'];
let (remainder, chunks) = slice.as_rchunks();
assert_eq!(remainder, &['l']);
assert_eq!(chunks, &[['o', 'r'], ['e', 'm']]);

pub fn array_chunks<const N: usize>(&self) -> ArrayChunks<'_, T, N>

🔬This is a nightly-only experimental API. (array_chunks #74985)

从切片的开头开始，一次返回对切片的 N 元素的迭代器。

这些块是数组引用，并且不重叠。 如果 N 不划分切片的长度，则最后 N-1 个元素将被省略，并可从迭代器的 remainder 函数中检索。

此方法与 chunks_exact 等效为 const 泛型。

Panics

如果 N 为 0，就会出现 panics。在此方法稳定之前，此检查很可能会更改为编译时错误。

Examples

#![feature(array_chunks)]
let slice = ['l', 'o', 'r', 'e', 'm'];
let mut iter = slice.array_chunks();
assert_eq!(iter.next().unwrap(), &['l', 'o']);
assert_eq!(iter.next().unwrap(), &['r', 'e']);
assert!(iter.next().is_none());
assert_eq!(iter.remainder(), &['m']);

pub const unsafe fn as_chunks_unchecked_mut<const N: usize>( &mut self ) -> &mut [[T; N]]

🔬This is a nightly-only experimental API. (slice_as_chunks #74985)

假设没有余数，将切片拆分为 N 个元素数组的切片。

Safety

只能在以下情况下调用

• 切片精确地分为 N 个元素块 (也称为 self.len() % N == 0)。
• N != 0.

Examples

#![feature(slice_as_chunks)]
let slice: &mut [char] = &mut ['l', 'o', 'r', 'e', 'm', '!'];
let chunks: &mut [[char; 1]] =
    // SAFETY: 1 个元素的块永远不会剩余
    unsafe { slice.as_chunks_unchecked_mut() };
chunks[0] = ['L'];
assert_eq!(chunks, &[['L'], ['o'], ['r'], ['e'], ['m'], ['!']]);
let chunks: &mut [[char; 3]] =
    // SAFETY: 切片长度 (6) 是 3 的倍数
    unsafe { slice.as_chunks_unchecked_mut() };
chunks[1] = ['a', 'x', '?'];
assert_eq!(slice, &['L', 'o', 'r', 'a', 'x', '?']);

// 这些是不健全的：
// `let chunks: &[[_; 5]] = slice.as_chunks_unchecked_mut()` // 切片长度不是 5 的倍数: `let chunks: &[[_; 0]] = slice.as_chunks_unchecked_mut()` // 永远不允许零长度的块

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

🔬This is a nightly-only experimental API. (slice_as_chunks #74985)

从切片的开头开始，将切片分成 N 个元素数组的切片，然后将其长度严格小于 N 的其余切片切成薄片。

Panics

如果 N 为 0，就会出现 panics。在此方法稳定之前，此检查很可能会更改为编译时错误。

Examples

#![feature(slice_as_chunks)]
let v = &mut [0, 0, 0, 0, 0];
let mut count = 1;

let (chunks, remainder) = v.as_chunks_mut();
remainder[0] = 9;
for chunk in chunks {
    *chunk = [count; 2];
    count += 1;
}
assert_eq!(v, &[1, 1, 2, 2, 9]);

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

🔬This is a nightly-only experimental API. (slice_as_chunks #74985)

从切片的末尾开始，将切片分成 N 个元素数组的切片，然后将其长度严格小于 N 的其余切片切成薄片。

Panics

如果 N 为 0，就会出现 panics。在此方法稳定之前，此检查很可能会更改为编译时错误。

Examples

#![feature(slice_as_chunks)]
let v = &mut [0, 0, 0, 0, 0];
let mut count = 1;

let (remainder, chunks) = v.as_rchunks_mut();
remainder[0] = 9;
for chunk in chunks {
    *chunk = [count; 2];
    count += 1;
}
assert_eq!(v, &[9, 1, 1, 2, 2]);

pub fn array_chunks_mut<const N: usize>(&mut self) -> ArrayChunksMut<'_, T, N>

🔬This is a nightly-only experimental API. (array_chunks #74985)

从切片的开头开始，一次返回对切片的 N 元素的迭代器。

这些块是可变数组引用，并且不重叠。 如果 N 不划分切片的长度，则最后 N-1 个元素将被省略，并可从迭代器的 into_remainder 函数中检索。

此方法与 chunks_exact_mut 等效为 const 泛型。

Panics

如果 N 为 0，就会出现 panics。在此方法稳定之前，此检查很可能会更改为编译时错误。

Examples

#![feature(array_chunks)]
let v = &mut [0, 0, 0, 0, 0];
let mut count = 1;

for chunk in v.array_chunks_mut() {
    *chunk = [count; 2];
    count += 1;
}
assert_eq!(v, &[1, 1, 2, 2, 0]);

pub fn array_windows<const N: usize>(&self) -> ArrayWindows<'_, T, N>

🔬This is a nightly-only experimental API. (array_windows #75027)

从切片的开头开始，返回重叠 N 元素的迭代器 windows。

这是 windows 的 const 泛型等效项。

如果 N 大于切片的大小，则不会返回 windows。

Panics

如果 N 是 panic 0. 在此方法稳定之前，此检查很可能会更改为编译时错误。

Examples

#![feature(array_windows)]
let slice = [0, 1, 2, 3];
let mut iter = slice.array_windows();
assert_eq!(iter.next().unwrap(), &[0, 1]);
assert_eq!(iter.next().unwrap(), &[1, 2]);
assert_eq!(iter.next().unwrap(), &[2, 3]);
assert!(iter.next().is_none());

pub fn rchunks(&self, chunk_size: usize) -> RChunks<'_, T>

从切片的末尾开始，一次返回对切片的 chunk_size 元素的迭代器。

块是切片，并且不重叠。如果 chunk_size 不划分切片的长度，则最后一块的长度将不为 chunk_size。

有关此迭代器的变体的信息，请参见 rchunks_exact，该变体返回始终完全相同的 chunk_size 元素的块; 对于相同的迭代器，请参见 chunks，但从切片的开头开始。

Panics

panic 会发生在如果 chunk_size 是 0.

Examples

let slice = ['l', 'o', 'r', 'e', 'm'];
let mut iter = slice.rchunks(2);
assert_eq!(iter.next().unwrap(), &['e', 'm']);
assert_eq!(iter.next().unwrap(), &['o', 'r']);
assert_eq!(iter.next().unwrap(), &['l']);
assert!(iter.next().is_none());

pub fn rchunks_mut(&mut self, chunk_size: usize) -> RChunksMut<'_, T>

从切片的末尾开始，一次返回对切片的 chunk_size 元素的迭代器。

块是可变切片，并且不重叠。如果 chunk_size 不划分切片的长度，则最后一块的长度将不为 chunk_size。

有关此迭代器的变体的信息，请参见 rchunks_exact_mut，该变体返回始终完全相同的 chunk_size 元素的块; 对于相同的迭代器，请参见 chunks_mut，但从切片的开头开始。

Panics

panic 会发生在如果 chunk_size 是 0.

Examples

let v = &mut [0, 0, 0, 0, 0];
let mut count = 1;

for chunk in v.rchunks_mut(2) {
    for elem in chunk.iter_mut() {
        *elem += count;
    }
    count += 1;
}
assert_eq!(v, &[3, 2, 2, 1, 1]);

pub fn rchunks_exact(&self, chunk_size: usize) -> RChunksExact<'_, T>

从切片的末尾开始，一次返回对切片的 chunk_size 元素的迭代器。

块是切片，并且不重叠。 如果 chunk_size 不划分切片的长度，则最后 chunk_size-1 个元素将被省略，并可从迭代器的 remainder 函数中检索。

由于每个块都有 chunk_size 元素，编译器通常可以比 rchunks 更好地优化生成的代码。

请参见 rchunks 以获取此迭代器的变体，该变体还以较小的块的形式返回其余部分，并以 chunks_exact 获取相同的迭代器，但从切片的开头开始。

Panics

panic 会发生在如果 chunk_size 是 0.

Examples

let slice = ['l', 'o', 'r', 'e', 'm'];
let mut iter = slice.rchunks_exact(2);
assert_eq!(iter.next().unwrap(), &['e', 'm']);
assert_eq!(iter.next().unwrap(), &['o', 'r']);
assert!(iter.next().is_none());
assert_eq!(iter.remainder(), &['l']);

pub fn rchunks_exact_mut(&mut self, chunk_size: usize) -> RChunksExactMut<'_, T>

从切片的末尾开始，一次返回对切片的 chunk_size 元素的迭代器。

块是可变切片，并且不重叠。 如果 chunk_size 不划分切片的长度，则最后 chunk_size-1 个元素将被省略，并可从迭代器的 into_remainder 函数中检索。

由于每个块都具有完全 chunk_size 元素，因此与 chunks_mut 相比，编译器通常可以更好地优化结果代码。

请参见 rchunks_mut 以获取此迭代器的变体，该变体还以较小的块的形式返回其余部分，并以 chunks_exact_mut 获取相同的迭代器，但从切片的开头开始。

Panics

panic 会发生在如果 chunk_size 是 0.

Examples

let v = &mut [0, 0, 0, 0, 0];
let mut count = 1;

for chunk in v.rchunks_exact_mut(2) {
    for elem in chunk.iter_mut() {
        *elem += count;
    }
    count += 1;
}
assert_eq!(v, &[0, 2, 2, 1, 1]);

pub fn group_by<F>(&self, pred: F) -> GroupBy<'_, T, F> where F: FnMut(&T, &T) -> bool,

🔬This is a nightly-only experimental API. (slice_group_by #80552)

返回在切片上使用迭代器生成迭代器的迭代器，这些谓词使用谓词将它们分隔开。

谓词在紧随其后的两个元素上调用，这意味着谓词在 slice[0] 和 slice[1] 上调用，然后在 slice[1] 和 slice[2] 上调用，依此类推。

Examples

#![feature(slice_group_by)]

let slice = &[1, 1, 1, 3, 3, 2, 2, 2];

let mut iter = slice.group_by(|a, b| a == b);

assert_eq!(iter.next(), Some(&[1, 1, 1][..]));
assert_eq!(iter.next(), Some(&[3, 3][..]));
assert_eq!(iter.next(), Some(&[2, 2, 2][..]));
assert_eq!(iter.next(), None);

此方法可用于提取排序的子切片：

#![feature(slice_group_by)]

let slice = &[1, 1, 2, 3, 2, 3, 2, 3, 4];

let mut iter = slice.group_by(|a, b| a <= b);

assert_eq!(iter.next(), Some(&[1, 1, 2, 3][..]));
assert_eq!(iter.next(), Some(&[2, 3][..]));
assert_eq!(iter.next(), Some(&[2, 3, 4][..]));
assert_eq!(iter.next(), None);

pub fn group_by_mut<F>(&mut self, pred: F) -> GroupByMut<'_, T, F> where F: FnMut(&T, &T) -> bool,

🔬This is a nightly-only experimental API. (slice_group_by #80552)

返回在切片上使用谓词将其分离的迭代器，以生成不重叠的可变元素游程。

谓词在紧随其后的两个元素上调用，这意味着谓词在 slice[0] 和 slice[1] 上调用，然后在 slice[1] 和 slice[2] 上调用，依此类推。

Examples

#![feature(slice_group_by)]

let slice = &mut [1, 1, 1, 3, 3, 2, 2, 2];

let mut iter = slice.group_by_mut(|a, b| a == b);

assert_eq!(iter.next(), Some(&mut [1, 1, 1][..]));
assert_eq!(iter.next(), Some(&mut [3, 3][..]));
assert_eq!(iter.next(), Some(&mut [2, 2, 2][..]));
assert_eq!(iter.next(), None);

此方法可用于提取排序的子切片：

#![feature(slice_group_by)]

let slice = &mut [1, 1, 2, 3, 2, 3, 2, 3, 4];

let mut iter = slice.group_by_mut(|a, b| a <= b);

assert_eq!(iter.next(), Some(&mut [1, 1, 2, 3][..]));
assert_eq!(iter.next(), Some(&mut [2, 3][..]));
assert_eq!(iter.next(), Some(&mut [2, 3, 4][..]));
assert_eq!(iter.next(), None);

pub const fn split_at(&self, mid: usize) -> (&[T], &[T])

在索引处将一个切片分为两个。

第一个将包含 [0, mid) 的所有索引 (不包括索引 mid 本身)，第二个将包含 [mid, len) 的所有索引 (不包括索引 len 本身)。

Panics

如果为 mid > len，就会出现 panics。

Examples

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

{
   let (left, right) = v.split_at(0);
   assert_eq!(left, []);
   assert_eq!(right, [1, 2, 3, 4, 5, 6]);
}

{
    let (left, right) = v.split_at(2);
    assert_eq!(left, [1, 2]);
    assert_eq!(right, [3, 4, 5, 6]);
}

{
    let (left, right) = v.split_at(6);
    assert_eq!(left, [1, 2, 3, 4, 5, 6]);
    assert_eq!(right, []);
}

pub fn split_at_mut(&mut self, mid: usize) -> (&mut [T], &mut [T])

在索引处将一个可变切片分成两个。

第一个将包含 [0, mid) 的所有索引 (不包括索引 mid 本身)，第二个将包含 [mid, len) 的所有索引 (不包括索引 len 本身)。

Panics

如果为 mid > len，就会出现 panics。

Examples

let mut v = [1, 0, 3, 0, 5, 6];
let (left, right) = v.split_at_mut(2);
assert_eq!(left, [1, 0]);
assert_eq!(right, [3, 0, 5, 6]);
left[1] = 2;
right[1] = 4;
assert_eq!(v, [1, 2, 3, 4, 5, 6]);

pub unsafe fn split_at_unchecked(&self, mid: usize) -> (&[T], &[T])

🔬This is a nightly-only experimental API. (slice_split_at_unchecked #76014)

在索引处将一个切片分为两个，而无需进行边界检查。

第一个将包含 [0, mid) 的所有索引 (不包括索引 mid 本身)，第二个将包含 [mid, len) 的所有索引 (不包括索引 len 本身)。

有关安全的选择，请参见 split_at。

Safety

即使没有使用所得的引用，使用越界索引调用此方法也是 undefined behavior。调用者必须确保 0 <= mid <= self.len().

Examples

#![feature(slice_split_at_unchecked)]

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

unsafe {
   let (left, right) = v.split_at_unchecked(0);
   assert_eq!(left, []);
   assert_eq!(right, [1, 2, 3, 4, 5, 6]);
}

unsafe {
    let (left, right) = v.split_at_unchecked(2);
    assert_eq!(left, [1, 2]);
    assert_eq!(right, [3, 4, 5, 6]);
}

unsafe {
    let (left, right) = v.split_at_unchecked(6);
    assert_eq!(left, [1, 2, 3, 4, 5, 6]);
    assert_eq!(right, []);
}

pub unsafe fn split_at_mut_unchecked( &mut self, mid: usize ) -> (&mut [T], &mut [T])

🔬This is a nightly-only experimental API. (slice_split_at_unchecked #76014)

在索引处将一个可变切片分为两个，而无需进行边界检查。

第一个将包含 [0, mid) 的所有索引 (不包括索引 mid 本身)，第二个将包含 [mid, len) 的所有索引 (不包括索引 len 本身)。

有关安全的选择，请参见 split_at_mut。

Safety

即使没有使用所得的引用，使用越界索引调用此方法也是 undefined behavior。调用者必须确保 0 <= mid <= self.len().

Examples

#![feature(slice_split_at_unchecked)]

let mut v = [1, 0, 3, 0, 5, 6];
// 限制借用的生命周期
unsafe {
    let (left, right) = v.split_at_mut_unchecked(2);
    assert_eq!(left, [1, 0]);
    assert_eq!(right, [3, 0, 5, 6]);
    left[1] = 2;
    right[1] = 4;
}
assert_eq!(v, [1, 2, 3, 4, 5, 6]);

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

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

将一个切片分成一个数组和一个索引处的剩余切片。

该数组将包含来自 [0, N) 的所有索引 (不包括索引 N 本身)，并且切片将包含来自 [N, len) 的所有索引 (不包括索引 len 本身)。

Panics

如果 N > len，就会出现 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 N: usize>(&mut self) -> (&mut [T; N], &mut [T])

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

将一个可变切片分成一个数组和一个索引处的剩余切片。

该数组将包含来自 [0, N) 的所有索引 (不包括索引 N 本身)，并且切片将包含来自 [N, len) 的所有索引 (不包括索引 len 本身)。

Panics

如果 N > len，就会出现 panics。

Examples

#![feature(split_array)]

let mut v = &mut [1, 0, 3, 0, 5, 6][..];
let (left, right) = v.split_array_mut::<2>();
assert_eq!(left, &mut [1, 0]);
assert_eq!(right, [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 N: usize>(&self) -> (&[T], &[T; N])

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

将一个切片分成一个数组和一个从末尾开始的索引处的剩余切片。

该切片将包含来自 [0, len - N) 的所有索引 (不包括索引 len - N 本身)，而数组将包含来自 [len - N, len) 的所有索引 (不包括索引 len 本身)。

Panics

如果 N > len，就会出现 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 N: usize>(&mut self) -> (&mut [T], &mut [T; N])

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

将一个可变切片分成一个数组和一个从末尾开始的索引处的剩余切片。

该切片将包含来自 [0, len - N) 的所有索引 (不包括索引 N 本身)，而数组将包含来自 [len - N, len) 的所有索引 (不包括索引 len 本身)。

Panics

如果 N > len，就会出现 panics。

Examples

#![feature(split_array)]

let mut v = &mut [1, 0, 3, 0, 5, 6][..];
let (left, right) = v.rsplit_array_mut::<4>();
assert_eq!(left, [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 split<F>(&self, pred: F) -> Split<'_, T, F> where F: FnMut(&T) -> bool,

返回由与 pred 匹配的元素分隔的子切片上的迭代器。 匹配的元素不包含在子切片中。

Examples

let slice = [10, 40, 33, 20];
let mut iter = slice.split(|num| num % 3 == 0);

assert_eq!(iter.next().unwrap(), &[10, 40]);
assert_eq!(iter.next().unwrap(), &[20]);
assert!(iter.next().is_none());

如果第一个元素匹配，则空切片将是迭代器返回的第一个项。 同样，如果切片中的最后一个元素匹配，则空切片将是迭代器返回的最后一个项：

let slice = [10, 40, 33];
let mut iter = slice.split(|num| num % 3 == 0);

assert_eq!(iter.next().unwrap(), &[10, 40]);
assert_eq!(iter.next().unwrap(), &[]);
assert!(iter.next().is_none());

如果两个匹配的元素直接相邻，则它们之间将出现一个空的切片：

let slice = [10, 6, 33, 20];
let mut iter = slice.split(|num| num % 3 == 0);

assert_eq!(iter.next().unwrap(), &[10]);
assert_eq!(iter.next().unwrap(), &[]);
assert_eq!(iter.next().unwrap(), &[20]);
assert!(iter.next().is_none());

pub fn split_mut<F>(&mut self, pred: F) -> SplitMut<'_, T, F> where F: FnMut(&T) -> bool,

返回由匹配 pred 的元素分隔的可变子切片上的迭代器。 匹配的元素不包含在子切片中。

Examples

let mut v = [10, 40, 30, 20, 60, 50];

for group in v.split_mut(|num| *num % 3 == 0) {
    group[0] = 1;
}
assert_eq!(v, [1, 40, 30, 1, 60, 1]);

pub fn split_inclusive<F>(&self, pred: F) -> SplitInclusive<'_, T, F> where F: FnMut(&T) -> bool,

返回由与 pred 匹配的元素分隔的子切片上的迭代器。 匹配的元素包含在上一个子切片的末尾作为终止符。

Examples

let slice = [10, 40, 33, 20];
let mut iter = slice.split_inclusive(|num| num % 3 == 0);

assert_eq!(iter.next().unwrap(), &[10, 40, 33]);
assert_eq!(iter.next().unwrap(), &[20]);
assert!(iter.next().is_none());

如果切片的最后一个元素匹配，则该元素将被视为前一个切片的终止符。

该切片将是迭代器返回的最后一个项目。

let slice = [3, 10, 40, 33];
let mut iter = slice.split_inclusive(|num| num % 3 == 0);

assert_eq!(iter.next().unwrap(), &[3]);
assert_eq!(iter.next().unwrap(), &[10, 40, 33]);
assert!(iter.next().is_none());

pub fn split_inclusive_mut<F>(&mut self, pred: F) -> SplitInclusiveMut<'_, T, F> where F: FnMut(&T) -> bool,

返回由匹配 pred 的元素分隔的可变子切片上的迭代器。 匹配的元素作为终止符包含在先前的子切片中。

Examples

let mut v = [10, 40, 30, 20, 60, 50];

for group in v.split_inclusive_mut(|num| *num % 3 == 0) {
    let terminator_idx = group.len()-1;
    group[terminator_idx] = 1;
}
assert_eq!(v, [10, 40, 1, 20, 1, 1]);

pub fn rsplit<F>(&self, pred: F) -> RSplit<'_, T, F> where F: FnMut(&T) -> bool,

在子切片上返回一个迭代器，该迭代器由与 pred 匹配的元素分隔，从切片的末尾开始并向后工作。 匹配的元素不包含在子切片中。

Examples

let slice = [11, 22, 33, 0, 44, 55];
let mut iter = slice.rsplit(|num| *num == 0);

assert_eq!(iter.next().unwrap(), &[44, 55]);
assert_eq!(iter.next().unwrap(), &[11, 22, 33]);
assert_eq!(iter.next(), None);

与 split() 一样，如果第一个或最后一个元素匹配，则空切片将是迭代器返回的第一个 (或最后一个) 项。

let v = &[0, 1, 1, 2, 3, 5, 8];
let mut it = v.rsplit(|n| *n % 2 == 0);
assert_eq!(it.next().unwrap(), &[]);
assert_eq!(it.next().unwrap(), &[3, 5]);
assert_eq!(it.next().unwrap(), &[1, 1]);
assert_eq!(it.next().unwrap(), &[]);
assert_eq!(it.next(), None);

pub fn rsplit_mut<F>(&mut self, pred: F) -> RSplitMut<'_, T, F> where F: FnMut(&T) -> bool,

返回在可变子切片上的迭代器，该子切片由与 pred 匹配的元素分隔，从切片的末尾开始并向后工作。 匹配的元素不包含在子切片中。

Examples

let mut v = [100, 400, 300, 200, 600, 500];

let mut count = 0;
for group in v.rsplit_mut(|num| *num % 3 == 0) {
    count += 1;
    group[0] = count;
}
assert_eq!(v, [3, 400, 300, 2, 600, 1]);

pub fn splitn<F>(&self, n: usize, pred: F) -> SplitN<'_, T, F> where F: FnMut(&T) -> bool,

在子切片上返回一个迭代器，该子切片由与 pred 匹配的元素分隔，限于最多返回 n 项。 匹配的元素不包含在子切片中。

返回的最后一个元素 (如果有) 将包含切片的其余部分。

Examples

按 3 的整数倍数 (即 [10, 40]，[20, 60, 50]) 打印一次切片分割：

let v = [10, 40, 30, 20, 60, 50];

for group in v.splitn(2, |num| *num % 3 == 0) {
    println!("{group:?}");
}

pub fn splitn_mut<F>(&mut self, n: usize, pred: F) -> SplitNMut<'_, T, F> where F: FnMut(&T) -> bool,

返回由匹配 pred 的元素分隔的子切片的迭代器，限制为最多返回 n 项。 匹配的元素不包含在子切片中。

返回的最后一个元素 (如果有) 将包含切片的其余部分。

Examples

let mut v = [10, 40, 30, 20, 60, 50];

for group in v.splitn_mut(2, |num| *num % 3 == 0) {
    group[0] = 1;
}
assert_eq!(v, [1, 40, 30, 1, 60, 50]);

pub fn rsplitn<F>(&self, n: usize, pred: F) -> RSplitN<'_, T, F> where F: FnMut(&T) -> bool,

在子切片上返回一个迭代器，该子切片由与 pred 匹配的元素分隔，最多只能返回 n 项。 该操作从切片的末尾开始并向后工作。 匹配的元素不包含在子切片中。

返回的最后一个元素 (如果有) 将包含切片的其余部分。

Examples

从末尾开始，将切片拆分打印一次，并被 3 整除的数字 (即 [50]，[10, 40, 30, 20]) ：

let v = [10, 40, 30, 20, 60, 50];

for group in v.rsplitn(2, |num| *num % 3 == 0) {
    println!("{group:?}");
}

pub fn rsplitn_mut<F>(&mut self, n: usize, pred: F) -> RSplitNMut<'_, T, F> where F: FnMut(&T) -> bool,

在子切片上返回一个迭代器，该子切片由与 pred 匹配的元素分隔，最多只能返回 n 项。 该操作从切片的末尾开始并向后工作。 匹配的元素不包含在子切片中。

返回的最后一个元素 (如果有) 将包含切片的其余部分。

Examples

let mut s = [10, 40, 30, 20, 60, 50];

for group in s.rsplitn_mut(2, |num| *num % 3 == 0) {
    group[0] = 1;
}
assert_eq!(s, [1, 40, 30, 20, 60, 1]);

pub fn contains(&self, x: &T) -> boolwhere T: PartialEq<T>,

如果切片包含具有给定值的元素，则返回 true。

这个操作是 O(n)。

请注意，如果您有一个排序切片，binary_search 可能会更快。

Examples

let v = [10, 40, 30];
assert!(v.contains(&30));
assert!(!v.contains(&50));

如果您没有 &T，但有其他一些可以与之比较的值 (例如，String 实现 PartialEq<str>)，则可以使用 iter().any：

let v = [String::from("hello"), String::from("world")]; // `String` 切片
assert!(v.iter().any(|e| e == "hello")); // 用 `&str` 搜索
assert!(!v.iter().any(|e| e == "hi"));

pub fn starts_with(&self, needle: &[T]) -> boolwhere T: PartialEq<T>,

如果 needle 是切片的前缀，则返回 true。

Examples

let v = [10, 40, 30];
assert!(v.starts_with(&[10]));
assert!(v.starts_with(&[10, 40]));
assert!(!v.starts_with(&[50]));
assert!(!v.starts_with(&[10, 50]));

如果 needle 为空切片，则始终返回 true：

let v = &[10, 40, 30];
assert!(v.starts_with(&[]));
let v: &[u8] = &[];
assert!(v.starts_with(&[]));

pub fn ends_with(&self, needle: &[T]) -> boolwhere T: PartialEq<T>,

如果 needle 是切片的后缀，则返回 true。

Examples

let v = [10, 40, 30];
assert!(v.ends_with(&[30]));
assert!(v.ends_with(&[40, 30]));
assert!(!v.ends_with(&[50]));
assert!(!v.ends_with(&[50, 30]));

如果 needle 为空切片，则始终返回 true：

let v = &[10, 40, 30];
assert!(v.ends_with(&[]));
let v: &[u8] = &[];
assert!(v.ends_with(&[]));

pub fn strip_prefix<P>(&self, prefix: &P) -> Option<&[T]>where P: SlicePattern<Item = T> + ?Sized, T: PartialEq<T>,

返回带有删除的前缀的子切片。

如果切片以 prefix 开头，则返回前缀在 Some 中的子切片。 如果 prefix 为空，则只需返回原始切片。

如果切片不是以 prefix 开头，则返回 None。

Examples

let v = &[10, 40, 30];
assert_eq!(v.strip_prefix(&[10]), Some(&[40, 30][..]));
assert_eq!(v.strip_prefix(&[10, 40]), Some(&[30][..]));
assert_eq!(v.strip_prefix(&[50]), None);
assert_eq!(v.strip_prefix(&[10, 50]), None);

let prefix : &str = "he";
assert_eq!(b"hello".strip_prefix(prefix.as_bytes()),
           Some(b"llo".as_ref()));

pub fn strip_suffix<P>(&self, suffix: &P) -> Option<&[T]>where P: SlicePattern<Item = T> + ?Sized, T: PartialEq<T>,

返回删除后缀的子分片。

如果切片以 suffix 结尾，则返回后缀在 Some 中的子切片。 如果 suffix 为空，则只需返回原始切片。

如果切片不以 suffix 结尾，则返回 None。

Examples

let v = &[10, 40, 30];
assert_eq!(v.strip_suffix(&[30]), Some(&[10, 40][..]));
assert_eq!(v.strip_suffix(&[40, 30]), Some(&[10][..]));
assert_eq!(v.strip_suffix(&[50]), None);
assert_eq!(v.strip_suffix(&[50, 30]), None);

pub fn binary_search(&self, x: &T) -> Result<usize, usize>where T: Ord,

Binary 在此切片中搜索给定元素。 如果切片没有排序，返回的结果是不确定的，没有意义。

如果找到该值，则返回 Result::Ok，其中包含匹配元素的索引。 如果有多个匹配项，则可以返回任何一个匹配项。 索引的选择是确定的，但在 Rust 的未来版本中可能会发生变化。 如果找不到该值，则返回 Result::Err，其中包含在保留排序顺序的同时可以在其中插入匹配元素的索引。

另请参见 binary_search_by，binary_search_by_key 和 partition_point。

Examples

查找一系列四个元素。 找到第一个，具有唯一确定的位置； 没有找到第二个和第三个； 第四个可以匹配 [1, 4] 中的任何位置。

let s = [0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55];

assert_eq!(s.binary_search(&13),  Ok(9));
assert_eq!(s.binary_search(&4),   Err(7));
assert_eq!(s.binary_search(&100), Err(13));
let r = s.binary_search(&1);
assert!(match r { Ok(1..=4) => true, _ => false, });

如果您想找到匹配项的整个范围，而不是任意匹配项，可以使用 partition_point 完成:

let s = [0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55];

let low = s.partition_point(|x| x < &1);
assert_eq!(low, 1);
let high = s.partition_point(|x| x <= &1);
assert_eq!(high, 5);
let r = s.binary_search(&1);
assert!((low..high).contains(&r.unwrap()));

assert!(s[..low].iter().all(|&x| x < 1));
assert!(s[low..high].iter().all(|&x| x == 1));
assert!(s[high..].iter().all(|&x| x > 1));

// 对于未找到的东西，等项的 "range" 为空
assert_eq!(s.partition_point(|x| x < &11), 9);
assert_eq!(s.partition_point(|x| x <= &11), 9);
assert_eq!(s.binary_search(&11), Err(9));

如果要向已排序的 vector 插入项，同时保持排序顺序，请考虑使用 partition_point:

let mut s = vec![0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55];
let num = 42;
let idx = s.partition_point(|&x| x < num);
// 以上等价于 `let idx = s.binary_search(&num).unwrap_or_else(|x| x);`
s.insert(idx, num);
assert_eq!(s, [0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 42, 55]);

pub fn binary_search_by<'a, F>(&'a self, f: F) -> Result<usize, usize>where F: FnMut(&'a T) -> Ordering,

Binary 使用比较器函数搜索此切片。

比较器函数应返回一个命令代码，指示其参数是 Less、Equal 还是 Greater 所需的目标。 如果切片未排序或比较器函数未实现与底层切片的排序顺序一致的顺序，则返回的结果是未指定的且无意义的。

如果找到该值，则返回 Result::Ok，其中包含匹配元素的索引。如果有多个匹配项，则可以返回任何一个匹配项。 索引的选择是确定的，但在 Rust 的未来版本中可能会发生变化。 如果找不到该值，则返回 Result::Err，其中包含在保留排序顺序的同时可以在其中插入匹配元素的索引。

另请参见 binary_search，binary_search_by_key 和 partition_point。

Examples

查找一系列四个元素。找到第一个，具有唯一确定的位置； 没有找到第二个和第三个； 第四个可以匹配 [1, 4] 中的任何位置。

let s = [0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55];

let seek = 13;
assert_eq!(s.binary_search_by(|probe| probe.cmp(&seek)), Ok(9));
let seek = 4;
assert_eq!(s.binary_search_by(|probe| probe.cmp(&seek)), Err(7));
let seek = 100;
assert_eq!(s.binary_search_by(|probe| probe.cmp(&seek)), Err(13));
let seek = 1;
let r = s.binary_search_by(|probe| probe.cmp(&seek));
assert!(match r { Ok(1..=4) => true, _ => false, });

pub fn binary_search_by_key<'a, B, F>( &'a self, b: &B, f: F ) -> Result<usize, usize>where F: FnMut(&'a T) -> B, B: Ord,

Binary 使用键提取函数搜索此切片。

假定按关键字对切片进行排序，例如使用相同的关键字提取函数对 sort_by_key 进行排序。 如果切片不按键排序，则返回结果未指定且无意义。

如果找到该值，则返回 Result::Ok，其中包含匹配元素的索引。 如果有多个匹配项，则可以返回任何一个匹配项。 索引的选择是确定的，但在 Rust 的未来版本中可能会发生变化。 如果找不到该值，则返回 Result::Err，其中包含在保留排序顺序的同时可以在其中插入匹配元素的索引。

另请参见 binary_search，binary_search_by 和 partition_point。

Examples

在成对的切片中按其第二个元素排序的一系列四个元素中查找。 找到第一个，具有唯一确定的位置； 没有找到第二个和第三个； 第四个可以匹配 [1, 4] 中的任何位置。

let s = [(0, 0), (2, 1), (4, 1), (5, 1), (3, 1),
         (1, 2), (2, 3), (4, 5), (5, 8), (3, 13),
         (1, 21), (2, 34), (4, 55)];

assert_eq!(s.binary_search_by_key(&13, |&(a, b)| b),  Ok(9));
assert_eq!(s.binary_search_by_key(&4, |&(a, b)| b),   Err(7));
assert_eq!(s.binary_search_by_key(&100, |&(a, b)| b), Err(13));
let r = s.binary_search_by_key(&1, |&(a, b)| b);
assert!(match r { Ok(1..=4) => true, _ => false, });

pub fn sort_unstable(&mut self)where T: Ord,

对三个元素进行排序，但可能不保留相等元素的顺序。

这种排序是不稳定的 (即可能重新排序相等的元素)，就地 (即不分配) 和 O(n*log(* n*)) 最坏的情况)。

当前实现

当前算法基于 Orson Peters 的 pattern-defeating 的快速排序，该算法将随机快速排序的快速平均情况与堆排序的快速最坏情况相结合，同时在具有特定模式的切片上实现了线性时间。 它使用一些随机化来避免退化的情况，但是使用固定的 seed 来始终提供确定性的行为。

除了在一些特殊情况下 (例如，当切片由多个串联的排序序列组成) 以外，它通常比稳定排序快。

Examples

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

v.sort_unstable();
assert!(v == [-5, -3, 1, 2, 4]);

pub fn sort_unstable_by<F>(&mut self, compare: F)where F: FnMut(&T, &T) -> Ordering,

使用比较器函数对三元进行排序，但可能不保留相等元素的顺序。

这种排序是不稳定的 (即可能重新排序相等的元素)，就地 (即不分配) 和 O(n*log(* n*)) 最坏的情况)。

比较器函数必须为切片中的元素定义总顺序。如果排序不全，则元素的顺序是未指定的。如果一个顺序是 (对于所有的a, b 和 c)，那么它就是一个总体顺序

• 完全和反对称的: a < b，a == b 或 a > b 之一正确，并且
• 可传递的，a < b 和 b < c 表示 a < c。== 和 > 必须保持相同。

例如，虽然 f64 由于 NaN != NaN 而不实现 Ord，但是当我们知道切片不包含 NaN 时，可以将 partial_cmp 用作我们的排序函数。

let mut floats = [5f64, 4.0, 1.0, 3.0, 2.0];
floats.sort_unstable_by(|a, b| a.partial_cmp(b).unwrap());
assert_eq!(floats, [1.0, 2.0, 3.0, 4.0, 5.0]);

当前实现

当前算法基于 Orson Peters 的 pattern-defeating 的快速排序，该算法将随机快速排序的快速平均情况与堆排序的快速最坏情况相结合，同时在具有特定模式的切片上实现了线性时间。 它使用一些随机化来避免退化的情况，但是使用固定的 seed 来始终提供确定性的行为。

除了在一些特殊情况下 (例如，当切片由多个串联的排序序列组成) 以外，它通常比稳定排序快。

Examples

let mut v = [5, 4, 1, 3, 2];
v.sort_unstable_by(|a, b| a.cmp(b));
assert!(v == [1, 2, 3, 4, 5]);

// 反向排序
v.sort_unstable_by(|a, b| b.cmp(a));
assert!(v == [5, 4, 3, 2, 1]);

pub fn sort_unstable_by_key<K, F>(&mut self, f: F)where F: FnMut(&T) -> K, K: Ord,

使用键提取函数对三个元素进行排序，但可能不保留相等元素的顺序。

这种排序是不稳定的 (即可能重新排序相等的元素)，就地 (即不分配) 和 O(m* * n ** log(n)) 最坏的情况，其中键函数为 O(m)。

当前实现

当前算法基于 Orson Peters 的 pattern-defeating 的快速排序，该算法将随机快速排序的快速平均情况与堆排序的快速最坏情况相结合，同时在具有特定模式的切片上实现了线性时间。 它使用一些随机化来避免退化的情况，但是使用固定的 seed 来始终提供确定性的行为。

由于其键调用策略，在键函数很昂贵的情况下，sort_unstable_by_key 可能比 sort_by_cached_key 慢。

Examples

let mut v = [-5i32, 4, 1, -3, 2];

v.sort_unstable_by_key(|k| k.abs());
assert!(v == [1, 2, -3, 4, -5]);

pub fn select_nth_unstable( &mut self, index: usize ) -> (&mut [T], &mut T, &mut [T])where T: Ord,

重新排序切片，以使 index 处的元素处于其最终排序位置。

此重新排序具有附加属性，即位置 i < index 处的任何值都将小于或等于位置 j > index 处的任何值。 此外，这种重新排序是不稳定的 (即 任何数量的相等元素都可以在位置 index 处就位 (即 不分配)，平均 O(n)。 最坏情况下的性能是 O(n log n)。 此函数在其他库中也称为 “kth element”。

它从重新排序的切片中返回以下三元组: index 之前的子切片、index 处的元素和 index 之后的子切片; 因此，这两个子切片中的值将分别小于或等于和大于或等于 index 处元素的值。

当前实现

目前的算法是基于 Pattern Defeating Quicksort 的 introselect 实现，也是 sort_unstable 的基础。 回退算法是使用 Tukey’s Ninther 进行 pivot 选择的 Median of Medians，这保证了所有输入的线性运行时间。

Panics

index >= len() 时为 Panics，这意味着在空片上始终为 panics。

Examples

let mut v = [-5i32, 4, 1, -3, 2];

// 找到中位数
v.select_nth_unstable(2);

// 根据我们对指定索引的排序方式，我们仅保证切片将是以下内容之一。
assert!(v == [-3, -5, 1, 2, 4] ||
        v == [-5, -3, 1, 2, 4] ||
        v == [-3, -5, 1, 4, 2] ||
        v == [-5, -3, 1, 4, 2]);

pub fn select_nth_unstable_by<F>( &mut self, index: usize, compare: F ) -> (&mut [T], &mut T, &mut [T])where F: FnMut(&T, &T) -> Ordering,

使用比较器函数对切片进行重新排序，以使 index 处的元素处于其最终排序位置。

此重排序具有附加属性，即使用比较器函数，位置 i < index 处的任何值将小于或等于位置 j > index 处的任何值。 此外，这种重新排序是不稳定的 (即任何数量的相等元素都可能在位置 index 结束)、就地 (即不分配) 和平均 O(n)。 最坏情况下的性能是 O(n log n)。此函数在其他库中也称为 “kth element”。

它从根据提供的比较函数重新排序的切片返回以下三元组: index 之前的子切片、index 处的元素和 index 之后的子切片; 因此，这两个子切片中的值将分别小于或等于和大于或等于 index 处元素的值。

当前实现

目前的算法是基于 Pattern Defeating Quicksort 的 introselect 实现，也是 sort_unstable 的基础。回退算法是使用 Tukey’s Ninther 进行 pivot 选择的 Median of Medians，这保证了所有输入的线性运行时间。

Panics

index >= len() 时为 Panics，这意味着在空片上始终为 panics。

Examples

let mut v = [-5i32, 4, 1, -3, 2];

// 查找中间值，好像切片是按降序排序的。
v.select_nth_unstable_by(2, |a, b| b.cmp(a));

// 根据我们对指定索引的排序方式，我们仅保证切片将是以下内容之一。
assert!(v == [2, 4, 1, -5, -3] ||
        v == [2, 4, 1, -3, -5] ||
        v == [4, 2, 1, -5, -3] ||
        v == [4, 2, 1, -3, -5]);

pub fn select_nth_unstable_by_key<K, F>( &mut self, index: usize, f: F ) -> (&mut [T], &mut T, &mut [T])where F: FnMut(&T) -> K, K: Ord,

使用键提取函数对切片进行重新排序，以使 index 处的元素处于其最终排序位置。

此重新排序具有附加属性，即使用键提取函数，位置 i < index 处的任何值将小于或等于位置 j > index 处的任何值。 此外，这种重新排序是不稳定的 (即任何数量的相等元素都可能在位置 index 结束)、就地 (即不分配) 和平均 O(n)。 最坏情况下的性能是 O(n log n)。 此函数在其他库中也称为 “kth element”。

它从根据提供的键提取函数重新排序的切片中返回以下三元组: index 之前的子切片、index 处的元素和 index 之后的子切片; 因此，这两个子切片中的值将分别小于或等于和大于或等于 index 处元素的值。

当前实现

当前算法基于用于 sort_unstable 的相同 quicksort 算法的 quickselect 部分。

Panics

index >= len() 时为 Panics，这意味着在空片上始终为 panics。

Examples

let mut v = [-5i32, 4, 1, -3, 2];

// 返回中间值，就好像数组是根据绝对值排序的一样。
v.select_nth_unstable_by_key(2, |a| a.abs());

// 根据我们对指定索引的排序方式，我们仅保证切片将是以下内容之一。
assert!(v == [1, 2, -3, 4, -5] ||
        v == [1, 2, -3, -5, 4] ||
        v == [2, 1, -3, 4, -5] ||
        v == [2, 1, -3, -5, 4]);

pub fn partition_dedup(&mut self) -> (&mut [T], &mut [T])where T: PartialEq<T>,

🔬This is a nightly-only experimental API. (slice_partition_dedup #54279)

根据 PartialEq trait 实现，将所有连续的重复元素移动到切片的末尾。

返回两个切片。第一个不包含连续的重复元素。 第二个包含没有指定顺序的所有重复项。

如果对切片进行排序，则第一个返回的切片不包含重复项。

Examples

#![feature(slice_partition_dedup)]

let mut slice = [1, 2, 2, 3, 3, 2, 1, 1];

let (dedup, duplicates) = slice.partition_dedup();

assert_eq!(dedup, [1, 2, 3, 2, 1]);
assert_eq!(duplicates, [2, 3, 1]);

pub fn partition_dedup_by<F>(&mut self, same_bucket: F) -> (&mut [T], &mut [T])where F: FnMut(&mut T, &mut T) -> bool,

🔬This is a nightly-only experimental API. (slice_partition_dedup #54279)

将除第一个连续元素之外的所有元素移动到满足给定相等关系的切片的末尾。

返回两个切片。第一个不包含连续的重复元素。 第二个包含没有指定顺序的所有重复项。

same_bucket 函数被引用传递给切片中的两个元素，并且必须确定这些元素是否相等。 元素以与它们在切片中的顺序相反的顺序传递，因此，如果 same_bucket(a, b) 返回 true，则 a 将在切片的末尾移动。

如果对切片进行排序，则第一个返回的切片不包含重复项。

Examples

#![feature(slice_partition_dedup)]

let mut slice = ["foo", "Foo", "BAZ", "Bar", "bar", "baz", "BAZ"];

let (dedup, duplicates) = slice.partition_dedup_by(|a, b| a.eq_ignore_ascii_case(b));

assert_eq!(dedup, ["foo", "BAZ", "Bar", "baz"]);
assert_eq!(duplicates, ["bar", "Foo", "BAZ"]);

pub fn partition_dedup_by_key<K, F>(&mut self, key: F) -> (&mut [T], &mut [T])where F: FnMut(&mut T) -> K, K: PartialEq<K>,

🔬This is a nightly-only experimental API. (slice_partition_dedup #54279)

将除了第一个连续元素之外的所有元素移动到解析为相同键的切片的末尾。

返回两个切片。第一个不包含连续的重复元素。 第二个包含没有指定顺序的所有重复项。

如果对切片进行排序，则第一个返回的切片不包含重复项。

Examples

#![feature(slice_partition_dedup)]

let mut slice = [10, 20, 21, 30, 30, 20, 11, 13];

let (dedup, duplicates) = slice.partition_dedup_by_key(|i| *i / 10);

assert_eq!(dedup, [10, 20, 30, 20, 11]);
assert_eq!(duplicates, [21, 30, 13]);

pub fn rotate_left(&mut self, mid: usize)

就地旋转切片，以使切片的第一个 mid 元素移至末尾，而最后一个 self.len() - mid 元素移至前端。 调用 rotate_left 后，先前在索引 mid 处的元素将成为切片中的第一个元素。

Panics

如果 mid 大于切片的长度，则此函数将为 panic。请注意，mid == self.len() 执行 not panic，并且是无操作旋转。

Complexity

花费线性时间 (以 self.len() 为单位)。

Examples

let mut a = ['a', 'b', 'c', 'd', 'e', 'f'];
a.rotate_left(2);
assert_eq!(a, ['c', 'd', 'e', 'f', 'a', 'b']);

旋转子切片：

let mut a = ['a', 'b', 'c', 'd', 'e', 'f'];
a[1..5].rotate_left(1);
assert_eq!(a, ['a', 'c', 'd', 'e', 'b', 'f']);

pub fn rotate_right(&mut self, k: usize)

就地旋转切片，以使切片的第一个 self.len() - k 元素移至末尾，而最后一个 k 元素移至前端。 调用 rotate_right 后，先前在索引 self.len() - k 处的元素将成为切片中的第一个元素。

Panics

如果 k 大于切片的长度，则此函数将为 panic。请注意，k == self.len() 执行 not panic，并且是无操作旋转。

Complexity

花费线性时间 (以 self.len() 为单位)。

Examples

let mut a = ['a', 'b', 'c', 'd', 'e', 'f'];
a.rotate_right(2);
assert_eq!(a, ['e', 'f', 'a', 'b', 'c', 'd']);

旋转子切片：

let mut a = ['a', 'b', 'c', 'd', 'e', 'f'];
a[1..5].rotate_right(1);
assert_eq!(a, ['a', 'e', 'b', 'c', 'd', 'f']);

pub fn fill(&mut self, value: T)where T: Clone,

通过克隆 value，用元素填充 self。

Examples

let mut buf = vec![0; 10];
buf.fill(1);
assert_eq!(buf, vec![1; 10]);

pub fn fill_with<F>(&mut self, f: F)where F: FnMut() -> T,

用重复调用闭包返回的元素填充 self。

此方法使用闭包创建新值。如果您希望给定值 Clone，请使用 fill。 如果要使用 Default trait 生成值，则可以传递 Default::default 作为参数。

Examples

let mut buf = vec![1; 10];
buf.fill_with(Default::default);
assert_eq!(buf, vec![0; 10]);

pub fn clone_from_slice(&mut self, src: &[T])where T: Clone,

将元素从 src 复制到 self。

src 的长度必须与 self 相同。

Panics

如果两个切片的长度不同，则此函数将为 panic。

Examples

将一个切片中的两个元素克隆到另一个中：

let src = [1, 2, 3, 4];
let mut dst = [0, 0];

// 由于切片必须具有相同的长度，因此我们将源切片从四个元素切成两个。
// 如果不这样做，它将为 panic。
dst.clone_from_slice(&src[2..]);

assert_eq!(src, [1, 2, 3, 4]);
assert_eq!(dst, [3, 4]);

Rust 强制规定在特定范围内只能有一个可变引用，而没有对特定数据段的不可变引用。 因此，尝试在单个切片上使用 clone_from_slice 将导致编译失败：

let mut slice = [1, 2, 3, 4, 5];

slice[..2].clone_from_slice(&slice[3..]); // 编译失败！

要解决此问题，我们可以使用 split_at_mut 从切片创建两个不同的子切片：

let mut slice = [1, 2, 3, 4, 5];

{
    let (left, right) = slice.split_at_mut(2);
    left.clone_from_slice(&right[1..]);
}

assert_eq!(slice, [4, 5, 3, 4, 5]);

pub fn copy_from_slice(&mut self, src: &[T])where T: Copy,

使用 memcpy 将所有元素从 src 复制到 self。

src 的长度必须与 self 相同。

如果 T 未实现 Copy，请使用 clone_from_slice。

Panics

如果两个切片的长度不同，则此函数将为 panic。

Examples

将切片中的两个元素复制到另一个中：

let src = [1, 2, 3, 4];
let mut dst = [0, 0];

// 由于切片必须具有相同的长度，因此我们将源切片从四个元素切成两个。
// 如果不这样做，它将为 panic。
dst.copy_from_slice(&src[2..]);

assert_eq!(src, [1, 2, 3, 4]);
assert_eq!(dst, [3, 4]);

Rust 强制规定在特定范围内只能有一个可变引用，而没有对特定数据段的不可变引用。 因此，尝试在单个切片上使用 copy_from_slice 将导致编译失败：

let mut slice = [1, 2, 3, 4, 5];

slice[..2].copy_from_slice(&slice[3..]); // 编译失败！

要解决此问题，我们可以使用 split_at_mut 从切片创建两个不同的子切片：

let mut slice = [1, 2, 3, 4, 5];

{
    let (left, right) = slice.split_at_mut(2);
    left.copy_from_slice(&right[1..]);
}

assert_eq!(slice, [4, 5, 3, 4, 5]);

pub fn copy_within<R>(&mut self, src: R, dest: usize)where R: RangeBounds<usize>, T: Copy,

使用记忆膜将元素从切片的一部分复制到自身的另一部分。

src 是 self 内要复制的范围。 dest 是要复制到的 self 范围内的起始索引，其长度与 src 相同。 这两个范围可能会重叠。 两个范围的末端必须小于或等于 self.len()。

Panics

如果任一范围超出了切片的末尾，或者 src 的末尾在开始点之前，则此函数将为 panic。

Examples

在切片中复制四个字节：

let mut bytes = *b"Hello, World!";

bytes.copy_within(1..5, 8);

assert_eq!(&bytes, b"Hello, Wello!");

pub fn swap_with_slice(&mut self, other: &mut [T])

交换 self 中的所有元素和 other 中的所有元素。

other 的长度必须与 self 相同。

Panics

如果两个切片的长度不同，则此函数将为 panic。

Example

在切片之间交换两个元素：

let mut slice1 = [0, 0];
let mut slice2 = [1, 2, 3, 4];

slice1.swap_with_slice(&mut slice2[2..]);

assert_eq!(slice1, [3, 4]);
assert_eq!(slice2, [1, 2, 0, 0]);

Rust 强制规定在特定范围内只能有一个对特定数据的可变引用。

因此，尝试在单个切片上使用 swap_with_slice 将导致编译失败：

let mut slice = [1, 2, 3, 4, 5];
slice[..2].swap_with_slice(&mut slice[3..]); // 编译失败！

要解决此问题，我们可以使用 split_at_mut 从切片创建两个不同的可变子切片：

let mut slice = [1, 2, 3, 4, 5];

{
    let (left, right) = slice.split_at_mut(2);
    left.swap_with_slice(&mut right[1..]);
}

assert_eq!(slice, [4, 5, 3, 1, 2]);

pub unsafe fn align_to<U>(&self) -> (&[T], &[U], &[T])

将切片转换为其他类型的切片，以确保保持类型的对齐。

此方法将切片分为三个不同的切片：前缀，正确对齐的新类型的中间切片和后缀切片。 没有具体说明切片是如何分割的; 中间部分可能比必要的要小。 但是，如果这未能返回最大中间部分，那是因为代码在性能无关紧要的上下文中运行，例如试图查找对齐错误的消毒程序。

在默认 (调试或发布) 执行中运行的常规代码将返回最大的中间部分。

当输入元素 T 或输出元素 U 的大小为零时，此方法无用，并且将返回原始切片而不拆分任何内容。

Safety

对于返回的中间切片中的元素，此方法本质上是 transmute，因此，与 transmute::<T, U> 有关的所有常见警告也适用于此。

Examples

基本用法：

unsafe {
    let bytes: [u8; 7] = [1, 2, 3, 4, 5, 6, 7];
    let (prefix, shorts, suffix) = bytes.align_to::<u16>();
    // less_efficient_algorithm_for_bytes(prefix);
    // more_efficient_algorithm_for_aligned_shorts(shorts);
    // less_efficient_algorithm_for_bytes(suffix);
}

pub unsafe fn align_to_mut<U>(&mut self) -> (&mut [T], &mut [U], &mut [T])

将不扩散切片转换为另一种类型的不扩散切片，确保保持类型的对齐。

此方法将切片分为三个不同的切片：前缀，正确对齐的新类型的中间切片和后缀切片。 没有具体说明切片是如何分割的; 中间部分可能比必要的要小。 但是，如果这未能返回最大中间部分，那是因为代码在性能无关紧要的上下文中运行，例如试图查找对齐错误的消毒程序。

在默认 (调试或发布) 执行中运行的常规代码将返回最大的中间部分。

当输入元素 T 或输出元素 U 的大小为零时，此方法无用，并且将返回原始切片而不拆分任何内容。

Safety

对于返回的中间切片中的元素，此方法本质上是 transmute，因此，与 transmute::<T, U> 有关的所有常见警告也适用于此。

Examples

基本用法：

unsafe {
    let mut bytes: [u8; 7] = [1, 2, 3, 4, 5, 6, 7];
    let (prefix, shorts, suffix) = bytes.align_to_mut::<u16>();
    // less_efficient_algorithm_for_bytes(prefix);
    // more_efficient_algorithm_for_aligned_shorts(shorts);
    // less_efficient_algorithm_for_bytes(suffix);
}

pub fn as_simd<const LANES: usize>(&self) -> (&[T], &[Simd<T, LANES>], &[T])where Simd<T, LANES>: AsRef<[T; LANES]>, T: SimdElement, LaneCount<LANES>: SupportedLaneCount,

🔬This is a nightly-only experimental API. (portable_simd #86656)

将切片分成前缀、中间对齐的 SIMD 类型和后缀。

这是一个围绕 slice::align_to 的安全包装器，因此具有与该方法相同的弱后置条件。 您只需要保证 self.len() == prefix.len() + middle.len() * LANES + suffix.len()。

值得注意的是，以下所有情况都是可能的：

• prefix.len() >= LANES.
• middle.is_empty() 尽管 self.len() >= 3 * LANES。
• suffix.len() >= LANES.

也就是说，这是一个安全的方法，所以如果您只编写安全的代码，那么这最多会导致不正确的逻辑，而不是不健全的。

Panics

如果 SIMD 类型的大小不同于标量的 LANES 倍，就会出现 panic。

在撰写本文时，Simd<T, LANES> 上的 trait 限制使这种情况永远不会发生，因为仅支持 2 的幂的 lanes 数。 有可能在未来的时候，这些限制可能会以某种方式取消，这样就有可能看到类似 LANES == 3 的 panics。

Examples

#![feature(portable_simd)]
use core::simd::SimdFloat;

let short = &[1, 2, 3];
let (prefix, middle, suffix) = short.as_simd::<4>();
assert_eq!(middle, []); // 中间没有足够的元素

// 它们可能以任何可能的方式在前缀和后缀之间拆分
let it = prefix.iter().chain(suffix).copied();
assert_eq!(it.collect::<Vec<_>>(), vec![1, 2, 3]);

fn basic_simd_sum(x: &[f32]) -> f32 {
    use std::ops::Add;
    use std::simd::f32x4;
    let (prefix, middle, suffix) = x.as_simd();
    let sums = f32x4::from_array([
        prefix.iter().copied().sum(),
        0.0,
        0.0,
        suffix.iter().copied().sum(),
    ]);
    let sums = middle.iter().copied().fold(sums, f32x4::add);
    sums.reduce_sum()
}

let numbers: Vec<f32> = (1..101).map(|x| x as _).collect();
assert_eq!(basic_simd_sum(&numbers[1..99]), 4949.0);

pub fn as_simd_mut<const LANES: usize>( &mut self ) -> (&mut [T], &mut [Simd<T, LANES>], &mut [T])where Simd<T, LANES>: AsMut<[T; LANES]>, T: SimdElement, LaneCount<LANES>: SupportedLaneCount,

🔬This is a nightly-only experimental API. (portable_simd #86656)

将一个可变切片拆分为一个可变前缀、一个对齐的 SIMD 类型的中间部分和一个可变后缀。

这是一个围绕 slice::align_to_mut 的安全包装器，因此具有与该方法相同的弱后置条件。 您只需要保证 self.len() == prefix.len() + middle.len() * LANES + suffix.len()。

值得注意的是，以下所有情况都是可能的：

• prefix.len() >= LANES.
• middle.is_empty() 尽管 self.len() >= 3 * LANES。
• suffix.len() >= LANES.

也就是说，这是一个安全的方法，所以如果您只编写安全的代码，那么这最多会导致不正确的逻辑，而不是不健全的。

这是 slice::as_simd 的可变版本； 请看这个例子。

Panics

如果 SIMD 类型的大小不同于标量的 LANES 倍，就会出现 panic。

在撰写本文时，Simd<T, LANES> 上的 trait 限制使这种情况永远不会发生，因为仅支持 2 的幂的 lanes 数。 有可能在未来的时候，这些限制可能会以某种方式取消，这样就有可能看到类似 LANES == 3 的 panics。

pub fn is_sorted(&self) -> boolwhere T: PartialOrd<T>,

🔬This is a nightly-only experimental API. (is_sorted #53485)

检查此切片的元素是否已排序。

也就是说，对于每个元素 a 及其后续元素 b，a <= b 必须成立。如果切片产生恰好产生零个或一个元素，则返回 true。

请注意，如果 Self::Item 仅是 PartialOrd，而不是 Ord，则上述定义意味着，如果任何两个连续的项都不具有可比性，则此函数将返回 false。

Examples

#![feature(is_sorted)]
let empty: [i32; 0] = [];

assert!([1, 2, 2, 9].is_sorted());
assert!(![1, 3, 2, 4].is_sorted());
assert!([0].is_sorted());
assert!(empty.is_sorted());
assert!(![0.0, 1.0, f32::NAN].is_sorted());

pub fn is_sorted_by<'a, F>(&'a self, compare: F) -> boolwhere F: FnMut(&'a T, &'a T) -> Option<Ordering>,

🔬This is a nightly-only experimental API. (is_sorted #53485)

检查此切片的元素是否使用给定的比较器函数进行排序。

该函数使用给定的 compare 函数来确定两个元素的顺序，而不是使用 PartialOrd::partial_cmp。 除此之外，它等效于 is_sorted。有关更多信息，请参见其文档。

pub fn is_sorted_by_key<'a, F, K>(&'a self, f: F) -> boolwhere F: FnMut(&'a T) -> K, K: PartialOrd<K>,

🔬This is a nightly-only experimental API. (is_sorted #53485)

检查此切片的元素是否使用给定的键提取函数进行排序。

该函数将直接比较由 f 确定的元素的键，而不是直接比较切片的元素。 除此之外，它等效于 is_sorted。有关更多信息，请参见其文档。

Examples

#![feature(is_sorted)]

assert!(["c", "bb", "aaa"].is_sorted_by_key(|s| s.len()));
assert!(![-2i32, -1, 0, 3].is_sorted_by_key(|n| n.abs()));

pub fn partition_point<P>(&self, pred: P) -> usizewhere P: FnMut(&T) -> bool,

根据给定的谓词返回分区点的索引 (第二个分区的第一个元素的索引)。

假定切片根据给定的谓词进行了分区。 这意味着谓词返回 true 的所有元素都在切片的开头，谓词返回 false 的所有元素都在切片的结尾。

例如，[7, 15, 3, 5, 4, 12, 6] 在谓词 x % 2 != 0 下进行分区 (所有奇数都在开头，所有偶数都在结尾)。

如果未对该切片进行分区，则返回的结果是不确定的且无意义的，因为此方法执行一种二进制搜索。

另请参见 binary_search，binary_search_by 和 binary_search_by_key。

Examples

let v = [1, 2, 3, 3, 5, 6, 7];
let i = v.partition_point(|&x| x < 5);

assert_eq!(i, 4);
assert!(v[..i].iter().all(|&x| x < 5));
assert!(v[i..].iter().all(|&x| !(x < 5)));

如果切片的所有元素都与谓词匹配，包括切片是否为空，则将返回切片的长度:

let a = [2, 4, 8];
assert_eq!(a.partition_point(|x| x < &100), a.len());
let a: [i32; 0] = [];
assert_eq!(a.partition_point(|x| x < &100), 0);

如果要在排序的 vector 中插入项目，同时保持排序顺序，请执行以下操作：

let mut s = vec![0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55];
let num = 42;
let idx = s.partition_point(|&x| x < num);
s.insert(idx, num);
assert_eq!(s, [0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 42, 55]);

pub fn take<R, 'a>(self: &mut &'a [T], range: R) -> Option<&'a [T]>where R: OneSidedRange<usize>,

🔬This is a nightly-only experimental API. (slice_take #62280)

删除与给定范围对应的子切片，并返回对它的引用。

如果给定的范围越界，则返回 None 并且不修改切片。

请注意，此方法仅接受 2.. 或 ..6 等单侧范围，但不接受 2..6。

Examples

获取切片的前三个元素：

#![feature(slice_take)]

let mut slice: &[_] = &['a', 'b', 'c', 'd'];
let mut first_three = slice.take(..3).unwrap();

assert_eq!(slice, &['d']);
assert_eq!(first_three, &['a', 'b', 'c']);

获取切片的最后两个元素：

#![feature(slice_take)]

let mut slice: &[_] = &['a', 'b', 'c', 'd'];
let mut tail = slice.take(2..).unwrap();

assert_eq!(slice, &['a', 'b']);
assert_eq!(tail, &['c', 'd']);

当 range 越界时会得到 None：

#![feature(slice_take)]

let mut slice: &[_] = &['a', 'b', 'c', 'd'];

assert_eq!(None, slice.take(5..));
assert_eq!(None, slice.take(..5));
assert_eq!(None, slice.take(..=4));
let expected: &[char] = &['a', 'b', 'c', 'd'];
assert_eq!(Some(expected), slice.take(..4));

pub fn take_mut<R, 'a>(self: &mut &'a mut [T], range: R) -> Option<&'a mut [T]>where R: OneSidedRange<usize>,

🔬This is a nightly-only experimental API. (slice_take #62280)

删除与给定范围对应的子切片，并返回对它的可变引用。

如果给定的范围越界，则返回 None 并且不修改切片。

请注意，此方法仅接受 2.. 或 ..6 等单侧范围，但不接受 2..6。

Examples

获取切片的前三个元素：

#![feature(slice_take)]

let mut slice: &mut [_] = &mut ['a', 'b', 'c', 'd'];
let mut first_three = slice.take_mut(..3).unwrap();

assert_eq!(slice, &mut ['d']);
assert_eq!(first_three, &mut ['a', 'b', 'c']);

获取切片的最后两个元素：

#![feature(slice_take)]

let mut slice: &mut [_] = &mut ['a', 'b', 'c', 'd'];
let mut tail = slice.take_mut(2..).unwrap();

assert_eq!(slice, &mut ['a', 'b']);
assert_eq!(tail, &mut ['c', 'd']);

当 range 越界时会得到 None：

#![feature(slice_take)]

let mut slice: &mut [_] = &mut ['a', 'b', 'c', 'd'];

assert_eq!(None, slice.take_mut(5..));
assert_eq!(None, slice.take_mut(..5));
assert_eq!(None, slice.take_mut(..=4));
let expected: &mut [_] = &mut ['a', 'b', 'c', 'd'];
assert_eq!(Some(expected), slice.take_mut(..4));

pub fn take_first<'a>(self: &mut &'a [T]) -> Option<&'a T>

🔬This is a nightly-only experimental API. (slice_take #62280)

删除切片的第一个元素，并返回对它的引用。

如果切片为空，则返回 None。

Examples

#![feature(slice_take)]

let mut slice: &[_] = &['a', 'b', 'c'];
let first = slice.take_first().unwrap();

assert_eq!(slice, &['b', 'c']);
assert_eq!(first, &'a');

pub fn take_first_mut<'a>(self: &mut &'a mut [T]) -> Option<&'a mut T>

🔬This is a nightly-only experimental API. (slice_take #62280)

删除切片的第一个元素，并返回对它的可变引用。

如果切片为空，则返回 None。

Examples

#![feature(slice_take)]

let mut slice: &mut [_] = &mut ['a', 'b', 'c'];
let first = slice.take_first_mut().unwrap();
*first = 'd';

assert_eq!(slice, &['b', 'c']);
assert_eq!(first, &'d');

pub fn take_last<'a>(self: &mut &'a [T]) -> Option<&'a T>

🔬This is a nightly-only experimental API. (slice_take #62280)

删除切片的最后一个元素，并返回对它的引用。

如果切片为空，则返回 None。

Examples

#![feature(slice_take)]

let mut slice: &[_] = &['a', 'b', 'c'];
let last = slice.take_last().unwrap();

assert_eq!(slice, &['a', 'b']);
assert_eq!(last, &'c');

pub fn take_last_mut<'a>(self: &mut &'a mut [T]) -> Option<&'a mut T>

🔬This is a nightly-only experimental API. (slice_take #62280)

删除切片的最后一个元素，并返回对它的可变引用。

如果切片为空，则返回 None。

Examples

#![feature(slice_take)]

let mut slice: &mut [_] = &mut ['a', 'b', 'c'];
let last = slice.take_last_mut().unwrap();
*last = 'd';

assert_eq!(slice, &['a', 'b']);
assert_eq!(last, &'d');

pub unsafe fn get_many_unchecked_mut<const N: usize>( &mut self, indices: [usize; N] ) -> [&mut T; N]

🔬This is a nightly-only experimental API. (get_many_mut #104642)

一次返回对多个索引的可变引用，不做任何检查。

有关安全的替代方案，请参见 get_many_mut。

Safety

使用重叠或越界索引调用此方法是 未定义的行为，即使未使用生成的引用也是如此。

Examples

#![feature(get_many_mut)]

let x = &mut [1, 2, 4];

unsafe {
    let [a, b] = x.get_many_unchecked_mut([0, 2]);
    *a *= 10;
    *b *= 100;
}
assert_eq!(x, &[10, 2, 400]);

pub fn get_many_mut<const N: usize>( &mut self, indices: [usize; N] ) -> Result<[&mut T; N], GetManyMutError<N>>

🔬This is a nightly-only experimental API. (get_many_mut #104642)

一次返回对多个索引的可变引用。

如果任何索引越界，或者同一索引被传递多次，则返回错误。

Examples

#![feature(get_many_mut)]

let v = &mut [1, 2, 3];
if let Ok([a, b]) = v.get_many_mut([0, 2]) {
    *a = 413;
    *b = 612;
}
assert_eq!(v, &[413, 2, 612]);

impl [f32]

pub fn sort_floats(&mut self)

🔬This is a nightly-only experimental API. (sort_floats #93396)

对浮点数切片进行排序。

这种排序是就地的 (即 不分配)，O(n* log(n)) 最坏情况，并使用 f32::total_cmp 定义的排序。

当前实现

这使用与 sort_unstable_by 相同的排序算法。

Examples

#![feature(sort_floats)]
let mut v = [2.6, -5e-8, f32::NAN, 8.29, f32::INFINITY, -1.0, 0.0, -f32::INFINITY, -0.0];

v.sort_floats();
let sorted = [-f32::INFINITY, -1.0, -5e-8, -0.0, 0.0, 2.6, 8.29, f32::INFINITY, f32::NAN];
assert_eq!(&v[..8], &sorted[..8]);
assert!(v[8].is_nan());

impl [f64]

pub fn sort_floats(&mut self)

🔬This is a nightly-only experimental API. (sort_floats #93396)

对浮点数切片进行排序。

这种排序是就地的 (即 不分配)，O(n* log(n)) 最坏情况，并使用 f64::total_cmp 定义的排序。

当前实现

这使用与 sort_unstable_by 相同的排序算法。

Examples

#![feature(sort_floats)]
let mut v = [2.6, -5e-8, f64::NAN, 8.29, f64::INFINITY, -1.0, 0.0, -f64::INFINITY, -0.0];

v.sort_floats();
let sorted = [-f64::INFINITY, -1.0, -5e-8, -0.0, 0.0, 2.6, 8.29, f64::INFINITY, f64::NAN];
assert_eq!(&v[..8], &sorted[..8]);
assert!(v[8].is_nan());

impl [u8]

pub fn is_ascii(&self) -> bool

检查此切片中的所有字节是否都在 ASCII 范围内。

pub const fn as_ascii(&self) -> Option<&[AsciiChar]>

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

如果此切片为 is_ascii，则将其作为 ASCII characters 的切片返回，否则返回 None。

pub const unsafe fn as_ascii_unchecked(&self) -> &[AsciiChar]

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

将此字节片段转换为 ASCII 字符片段，而不检查它们是否有效。

Safety

切片中的每个字节都必须在 0..=127 中，否则就是 UB。

pub fn eq_ignore_ascii_case(&self, other: &[u8]) -> bool

检查两个片是否是 ASCII 大小写不敏感的匹配项。

与 to_ascii_lowercase(a) == to_ascii_lowercase(b) 相同，但不分配和复制临时文件。

pub fn make_ascii_uppercase(&mut self)

将该切片原位转换为其 ASCII 大写形式。

ASCII 字母 ‘a’ 到 ‘z’ 映射到 ‘A’ 到 ‘Z’，但是非 ASCII 字母不变。

要返回新的大写值而不修改现有值，请使用 to_ascii_uppercase。

pub fn make_ascii_lowercase(&mut self)

将该切片原位转换为其 ASCII 小写等效项。

ASCII 字母 ‘A’ 到 ‘Z’ 映射到 ‘a’ 到 ‘z’，但是非 ASCII 字母不变。

要返回新的小写值而不修改现有值，请使用 to_ascii_lowercase。

pub fn escape_ascii(&self) -> EscapeAscii<'_>

返回一个迭代器，该迭代器产生此转义版本的一个 ASCII 字符串，将其视为一个 ASCII 字符串。

Examples

let s = b"0\t\r\n'\"\\\x9d";
let escaped = s.escape_ascii().to_string();
assert_eq!(escaped, "0\\t\\r\\n\\'\\\"\\\\\\x9d");

pub const fn trim_ascii_start(&self) -> &[u8]

🔬This is a nightly-only experimental API. (byte_slice_trim_ascii #94035)

返回删除了前导 ASCII 空白字节的字节切片。

‘Whitespace’ 是指 u8::is_ascii_whitespace 使用的定义。

Examples

#![feature(byte_slice_trim_ascii)]

assert_eq!(b" \t hello world\n".trim_ascii_start(), b"hello world\n");
assert_eq!(b"  ".trim_ascii_start(), b"");
assert_eq!(b"".trim_ascii_start(), b"");

pub const fn trim_ascii_end(&self) -> &[u8]

🔬This is a nightly-only experimental API. (byte_slice_trim_ascii #94035)

返回删除了尾随 ASCII 空白字节的字节切片。

‘Whitespace’ 是指 u8::is_ascii_whitespace 使用的定义。

Examples

#![feature(byte_slice_trim_ascii)]

assert_eq!(b"\r hello world\n ".trim_ascii_end(), b"\r hello world");
assert_eq!(b"  ".trim_ascii_end(), b"");
assert_eq!(b"".trim_ascii_end(), b"");

pub const fn trim_ascii(&self) -> &[u8]

🔬This is a nightly-only experimental API. (byte_slice_trim_ascii #94035)

返回删除了前导和尾随 ASCII 空白字节的字节切片。

‘Whitespace’ 是指 u8::is_ascii_whitespace 使用的定义。

Examples

#![feature(byte_slice_trim_ascii)]

assert_eq!(b"\r hello world\n ".trim_ascii(), b"hello world");
assert_eq!(b"  ".trim_ascii(), b"");
assert_eq!(b"".trim_ascii(), b"");

impl [AsciiChar]

pub const fn as_str(&self) -> &str

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

将这片 ASCII 字符视为 UTF-8 str。

pub const fn as_bytes(&self) -> &[u8]

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

将此 ASCII 字符片段视为 u8 字节片段。

impl [u8]

pub fn to_ascii_uppercase(&self) -> Vec<u8, Global>

返回一个 vector，其中包含此切片的副本，其中每个字节都映射到其等效的 ASCII 大写字母。

ASCII 字母 ‘a’ 到 ‘z’ 映射到 ‘A’ 到 ‘Z’，但是非 ASCII 字母不变。

要就地将值大写，请使用 make_ascii_uppercase。

pub fn to_ascii_lowercase(&self) -> Vec<u8, Global>

返回一个 vector，其中包含该切片的副本，其中每个字节均映射为其等效的 ASCII 小写字母。

ASCII 字母 ‘A’ 到 ‘Z’ 映射到 ‘a’ 到 ‘z’，但是非 ASCII 字母不变。

要就地小写该值，请使用 make_ascii_lowercase。

impl<T> [T]

pub fn sort(&mut self)where T: Ord,

对切片进行排序。

这种排序是稳定的 (即，不对相等的元素重新排序)，并且 O(n*log(* n*)) 最坏的情况)。

在适用时，首选不稳定排序，因为它通常比稳定排序快，并且不分配辅助内存。 请参见 sort_unstable。

当前实现

当前的算法是一种受 timsort 启发的自适应迭代合并排序。 在切片几乎被排序或由两个或多个依次连接的排序序列组成的情况下，它设计得非常快。

同样，它分配临时存储空间的大小是 self 的一半，但是对于短片，则使用非分配插入排序。

Examples

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

v.sort();
assert!(v == [-5, -3, 1, 2, 4]);

pub fn sort_by<F>(&mut self, compare: F)where F: FnMut(&T, &T) -> Ordering,

用比较器函数对切片进行排序。

这种排序是稳定的 (即，不对相等的元素重新排序)，并且 O(n*log(* n*)) 最坏的情况)。

比较器函数必须为切片中的元素定义总顺序。如果排序不全，则元素的顺序是未指定的。 如果一个顺序是 (对于所有的a, b 和 c)，那么它就是一个总体顺序

• 完全和反对称的: a < b，a == b 或 a > b 之一正确，并且
• 可传递的，a < b 和 b < c 表示 a < c。== 和 > 必须保持相同。

例如，虽然 f64 由于 NaN != NaN 而不实现 Ord，但是当我们知道切片不包含 NaN 时，可以将 partial_cmp 用作我们的排序函数。

let mut floats = [5f64, 4.0, 1.0, 3.0, 2.0];
floats.sort_by(|a, b| a.partial_cmp(b).unwrap());
assert_eq!(floats, [1.0, 2.0, 3.0, 4.0, 5.0]);

在适用时，首选不稳定排序，因为它通常比稳定排序快，并且不分配辅助内存。 请参见 sort_unstable_by。

当前实现

当前的算法是一种受 timsort 启发的自适应迭代合并排序。 在切片几乎被排序或由两个或多个依次连接的排序序列组成的情况下，它设计得非常快。

同样，它分配临时存储空间的大小是 self 的一半，但是对于短片，则使用非分配插入排序。

Examples

let mut v = [5, 4, 1, 3, 2];
v.sort_by(|a, b| a.cmp(b));
assert!(v == [1, 2, 3, 4, 5]);

// 反向排序
v.sort_by(|a, b| b.cmp(a));
assert!(v == [5, 4, 3, 2, 1]);

pub fn sort_by_key<K, F>(&mut self, f: F)where F: FnMut(&T) -> K, K: Ord,

用键提取函数对切片进行排序。

这种排序是稳定的 (即，不对相等的元素重新排序)，并且是 O(m* * n ** log(n)) 最坏的情况，其中键函数为 O(m)。

对于昂贵的键函数 (例如 不是简单的属性访问或基本操作的函数)，sort_by_cached_key 可能会显着提高速度，因为它不会重新计算元素键。

在适用时，首选不稳定排序，因为它通常比稳定排序快，并且不分配辅助内存。 请参见 sort_unstable_by_key。

当前实现

当前的算法是一种受 timsort 启发的自适应迭代合并排序。 在切片几乎被排序或由两个或多个依次连接的排序序列组成的情况下，它设计得非常快。

同样，它分配临时存储空间的大小是 self 的一半，但是对于短片，则使用非分配插入排序。

Examples

let mut v = [-5i32, 4, 1, -3, 2];

v.sort_by_key(|k| k.abs());
assert!(v == [1, 2, -3, 4, -5]);

pub fn sort_by_cached_key<K, F>(&mut self, f: F)where F: FnMut(&T) -> K, K: Ord,

用键提取函数对切片进行排序。

在排序过程中，每个元素最多调用一次 key 函数，通过使用临时存储来记住 key 评估的结果。 对 key 函数的调用顺序是未指定的，并且在标准库的未来版本中可能会发生变化。

这种排序是稳定的 (即，不对相等的元素重新排序)，并且 O(m* * n + n ** log(n)) 最坏的情况是，其中键函数为 O(m)。

对于简单的键函数 (例如，作为属性访问或基本操作的函数)，sort_by_key 可能会更快。

当前实现

当前算法基于 Orson Peters 的 pattern-defeating 的快速排序，该算法将随机快速排序的快速平均情况与堆排序的快速最坏情况相结合，同时在具有特定模式的切片上实现了线性时间。 它使用一些随机化来避免退化的情况，但是使用固定的 seed 来始终提供确定性的行为。

在最坏的情况下，该算法在 Vec<(K, usize)> 中分配切片长度的临时存储。

Examples

let mut v = [-5i32, 4, 32, -3, 2];

v.sort_by_cached_key(|k| k.to_string());
assert!(v == [-3, -5, 2, 32, 4]);

pub fn to_vec(&self) -> Vec<T, Global>where T: Clone,

将 self 复制到新的 Vec 中。

Examples

let s = [10, 40, 30];
let x = s.to_vec();
// 在此，`s` 和 `x` 可以独立修改。

pub fn to_vec_in<A>(&self, alloc: A) -> Vec<T, A>where A: Allocator, T: Clone,

🔬This is a nightly-only experimental API. (allocator_api #32838)

使用分配器将 self 复制到新的 Vec 中。

Examples

#![feature(allocator_api)]

use std::alloc::System;

let s = [10, 40, 30];
let x = s.to_vec_in(System);
// 在此，`s` 和 `x` 可以独立修改。

pub fn into_vec<A>(self: Box<[T], A>) -> Vec<T, A>where A: Allocator,

将 self 转换为 vector，而无需克隆或分配。

产生的 vector 可以通过 Vec 转换回 box<T> 的 into_boxed_slice 方法。

Examples

let s: Box<[i32]> = Box::new([10, 40, 30]);
let x = s.into_vec();
// `s` 不能再使用了，因为它已经转换成 `x`。

assert_eq!(x, vec![10, 40, 30]);

pub fn repeat(&self, n: usize) -> Vec<T, Global>where T: Copy,

通过复制切片 n 次创建 vector。

Panics

如果容量溢出，此函数将为 panic。

Examples

基本用法：

assert_eq!([1, 2].repeat(3), vec![1, 2, 1, 2, 1, 2]);

溢出时为 panic：

// 这将在运行时 panic
b"0123456789abcdef".repeat(usize::MAX);

pub fn concat<Item>(&self) -> <[T] as Concat<Item>>::Output where [T]: Concat<Item>, Item: ?Sized,

将 T 的切片展平为单个值 Self::Output。

Examples

assert_eq!(["hello", "world"].concat(), "helloworld");
assert_eq!([[1, 2], [3, 4]].concat(), [1, 2, 3, 4]);

pub fn join<Separator>( &self, sep: Separator ) -> <[T] as Join<Separator>>::Output where [T]: Join<Separator>,

将 T 的切片展平为单个值 Self::Output，并在每个值之间放置一个给定的分隔符。

Examples

assert_eq!(["hello", "world"].join(" "), "hello world");
assert_eq!([[1, 2], [3, 4]].join(&0), [1, 2, 0, 3, 4]);
assert_eq!([[1, 2], [3, 4]].join(&[0, 0][..]), [1, 2, 0, 0, 3, 4]);

pub fn connect<Separator>( &self, sep: Separator ) -> <[T] as Join<Separator>>::Output where [T]: Join<Separator>,

👎Deprecated since 1.3.0: renamed to join

将 T 的切片展平为单个值 Self::Output，并在每个值之间放置一个给定的分隔符。

Examples

assert_eq!(["hello", "world"].connect(" "), "hello world");
assert_eq!([[1, 2], [3, 4]].connect(&0), [1, 2, 0, 3, 4]);

Trait Implementations

impl<T> AsMut<[T]> for [T]

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

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

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

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

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

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

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

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

impl<T, A> AsMut<[T]> for Vec<T, A>where A: Allocator,

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

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

impl<T> AsRef<[T]> for [T]

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

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

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

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

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

impl<'a, T, A> AsRef<[T]> for Drain<'a, T, A>where A: Allocator,

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

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

impl<T, A> AsRef<[T]> for IntoIter<T, A>where A: Allocator,

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

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

impl<T> AsRef<[T]> for Iter<'_, T>

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

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

impl<T> AsRef<[T]> for IterMut<'_, T>

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

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

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

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

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

impl<T, A> AsRef<[T]> for Vec<T, A>where A: Allocator,

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

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

impl<'a> AsRef<[u8]> for Drain<'a>

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

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

impl AsRef<[u8]> for String

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

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

impl AsRef<[u8]> for str

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

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

impl AsciiExt for [u8]

type Owned = Vec<u8, Global>

👎Deprecated since 1.26.0: use inherent methods instead

复制的 ASCII 字符的容器类型。

fn is_ascii(&self) -> bool

👎Deprecated since 1.26.0: use inherent methods instead

检查该值是否在 ASCII 范围内。

fn to_ascii_uppercase(&self) -> Self::Owned

👎Deprecated since 1.26.0: use inherent methods instead

使值的副本等效于其 ASCII 大写字母。

fn to_ascii_lowercase(&self) -> Self::Owned

👎Deprecated since 1.26.0: use inherent methods instead

以等效的 ASCII 小写形式复制值。

fn eq_ignore_ascii_case(&self, o: &Self) -> bool

👎Deprecated since 1.26.0: use inherent methods instead

检查两个值是否为 ASCII 不区分大小写的匹配。

fn make_ascii_uppercase(&mut self)

👎Deprecated since 1.26.0: use inherent methods instead

将此类型就地转换为其 ASCII 大写等效项。

fn make_ascii_lowercase(&mut self)

👎Deprecated since 1.26.0: use inherent methods instead

将此类型就地转换为其 ASCII 小写等效项。

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

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

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

impl<T, A> Borrow<[T]> for Vec<T, A>where A: Allocator,

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

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

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

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

从拥有的值中借用。

impl<T, A> BorrowMut<[T]> for Vec<T, A>where A: Allocator,

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

从拥有的值中借用。

impl BufRead for &[u8]

fn fill_buf(&mut self) -> Result<&[u8]>

返回内部缓冲区的内容，如果内部缓冲区为空，则使用内部 reader 中的更多数据填充内部缓冲区。

fn consume(&mut self, amt: usize)

告诉此缓冲区 amt 字节已从缓冲区中消耗掉，因此在调用 read 时不再应返回它们。

fn has_data_left(&mut self) -> Result<bool>

🔬This is a nightly-only experimental API. (buf_read_has_data_left #86423)

检查底层 Read 是否有任何数据可供读取。

fn read_until(&mut self, byte: u8, buf: &mut Vec<u8>) -> Result<usize>

将所有字节读入 buf，直到到达定界符 byte 或 EOF。

fn read_line(&mut self, buf: &mut String) -> Result<usize>

读取所有字节直到到达换行符 (0xA 字节)，并将它们，追加，到提供的 String 缓冲区。

fn split(self, byte: u8) -> Split<Self> where Self: Sized,

返回对该字节 byte 上的 reader 拆分内容的迭代器。

fn lines(self) -> Lines<Self> where Self: Sized,

返回此 reader 的各行上的迭代器。

impl<T, A> Clone for Box<[T], A>where T: Clone, A: Allocator + Clone,

fn clone(&self) -> Box<[T], A>

返回值的副本。

fn clone_from(&mut self, other: &Box<[T], A>)

从 source 执行复制分配。

impl<T, V> Concat<T> for [V]where T: Clone, V: Borrow<[T]>,

type Output = Vec<T, Global>

🔬This is a nightly-only experimental API. (slice_concat_trait #27747)

串联后的结果类型

fn concat(slice: &[V]) -> Vec<T, Global>

🔬This is a nightly-only experimental API. (slice_concat_trait #27747)

[T]::concat 的实现

impl<S> Concat<str> for [S]where S: Borrow<str>,

Note: Concat<str> 中的 str 在这里没有意义。 trait 的这个类型参数的存在只是为了启用另一个 impl。

type Output = String

🔬This is a nightly-only experimental API. (slice_concat_trait #27747)

串联后的结果类型

fn concat(slice: &[S]) -> String

🔬This is a nightly-only experimental API. (slice_concat_trait #27747)

[T]::concat 的实现

impl<T> Debug for [T]where T: Debug,

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

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

impl<T> Default for &[T]

fn default() -> &[T]

创建一个空的切片。

impl<T> Default for &mut [T]

fn default() -> &mut [T]

创建一个可变的空切片。

impl<T> Default for Box<[T], Global>

fn default() -> Box<[T], Global>

返回类型的 “默认值”。

impl<T> From<&[T]> for Arc<[T]>where T: Clone,

fn from(v: &[T]) -> Arc<[T]>

分配一个引用计数的切片，并通过克隆 v 的项来填充它。

Example

let original: &[i32] = &[1, 2, 3];
let shared: Arc<[i32]> = Arc::from(original);
assert_eq!(&[1, 2, 3], &shared[..]);

impl<T> From<&[T]> for Box<[T], Global>where T: Clone,

fn from(slice: &[T]) -> Box<[T], Global>

将 &[T] 转换为 Box<[T]>

此转换在堆上分配并执行 slice 及其内容的副本。

Examples

// 创建 &[u8] which 将用于创建 Box<[u8]>
let slice: &[u8] = &[104, 101, 108, 108, 111];
let boxed_slice: Box<[u8]> = Box::from(slice);

println!("{boxed_slice:?}");

impl<T> From<&[T]> for Rc<[T]>where T: Clone,

fn from(v: &[T]) -> Rc<[T]>

分配一个引用计数的切片，并通过克隆 v 的项来填充它。

Example

let original: &[i32] = &[1, 2, 3];
let shared: Rc<[i32]> = Rc::from(original);
assert_eq!(&[1, 2, 3], &shared[..]);

impl<T> From<&[T]> for Vec<T, Global>where T: Clone,

fn from(s: &[T]) -> Vec<T, Global>

分配一个 Vec<T> 并通过克隆 s 的项来填充它。

Examples

assert_eq!(Vec::from(&[1, 2, 3][..]), vec![1, 2, 3]);

impl<'a, T> From<&'a [T]> for Cow<'a, [T]>where T: Clone,

fn from(s: &'a [T]) -> Cow<'a, [T]>

从一个切片创建一个 Cow 的 Borrowed 变体。

此转换不会分配或克隆数据。

impl<'data> From<&'data mut [MaybeUninit<u8>]> for BorrowedBuf<'data>

从未初始化的缓冲区创建一个新的 BorrowedBuf。

如果已知缓冲区的一部分已经初始化，则使用 set_init。

fn from(buf: &'data mut [MaybeUninit<u8>]) -> BorrowedBuf<'data>

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

impl<'data> From<&'data mut [u8]> for BorrowedBuf<'data>

从完全初始化的切片创建一个新的 BorrowedBuf。

fn from(slice: &'data mut [u8]) -> BorrowedBuf<'data>

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

impl<T> From<&mut [T]> for Vec<T, Global>where T: Clone,

fn from(s: &mut [T]) -> Vec<T, Global>

分配一个 Vec<T> 并通过克隆 s 的项来填充它。

Examples

assert_eq!(Vec::from(&mut [1, 2, 3][..]), vec![1, 2, 3]);

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

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

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

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

Examples

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

impl<A> From<Box<str, A>> for Box<[u8], A>where A: Allocator,

fn from(s: Box<str, A>) -> Box<[u8], A>

将 Box<str> 转换为 Box<[u8]>

这种转换不会在堆上分配，而是就地进行。

Examples

// 创建一个 Box<str>，该 Box<str> 将用于创建 Box<[u8]>
let boxed: Box<str> = Box::from("hello");
let boxed_str: Box<[u8]> = Box::from(boxed);

// 创建 &[u8] which 将用于创建 Box<[u8]>
let slice: &[u8] = &[104, 101, 108, 108, 111];
let boxed_slice = Box::from(slice);

assert_eq!(boxed_slice, boxed_str);

impl<T> From<Cow<'_, [T]>> for Box<[T], Global>where T: Clone,

fn from(cow: Cow<'_, [T]>) -> Box<[T], Global>

将 Cow<'_, [T]> 转换为 Box<[T]>

当 cow 是 Cow::Borrowed 变体时，此转换在堆上分配并复制底层切片。 否则，它将尝试重用拥有所有权的 Vec 的分配。

impl<T, A> From<Vec<T, A>> for Box<[T], A>where A: Allocator,

fn from(v: Vec<T, A>) -> Box<[T], A>

将 vector 转换为 boxed。

如果 v 有多余的容量，它的项将被移动到新分配的缓冲区中，缓冲区的容量恰好是正确的。

Examples

assert_eq!(Box::from(vec![1, 2, 3]), vec![1, 2, 3].into_boxed_slice());

任何多余的容量都将被删除：

let mut vec = Vec::with_capacity(10);
vec.extend([1, 2, 3]);

assert_eq!(Box::from(vec), vec![1, 2, 3].into_boxed_slice());

impl<I> FromIterator<I> for Box<[I], Global>

fn from_iter<T>(iter: T) -> Box<[I], Global>where T: IntoIterator<Item = I>,

从迭代器创建一个值。

impl<T> Hash for [T]where T: Hash,

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

将该值输入给定的 Hasher。

impl<T, I> Index<I> for [T]where I: SliceIndex<[T]>,

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

索引后返回的类型。

fn index(&self, index: I) -> &<I as SliceIndex<[T]>>::Output

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

impl<T, I> IndexMut<I> for [T]where I: SliceIndex<[T]>,

fn index_mut(&mut self, index: I) -> &mut <I as SliceIndex<[T]>>::Output

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

impl<'a, T> IntoIterator for &'a [T]

type Item = &'a T

被迭代的元素的类型。

type IntoIter = Iter<'a, T>

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

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

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

impl<'a, T> IntoIterator for &'a mut [T]

type Item = &'a mut T

被迭代的元素的类型。

type IntoIter = IterMut<'a, T>

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

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

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

impl<T, V> Join<&[T]> for [V]where T: Clone, V: Borrow<[T]>,

type Output = Vec<T, Global>

🔬This is a nightly-only experimental API. (slice_concat_trait #27747)

串联后的结果类型

fn join(slice: &[V], sep: &[T]) -> Vec<T, Global>

🔬This is a nightly-only experimental API. (slice_concat_trait #27747)

[T]::join 的实现

impl<S: Borrow<OsStr>> Join<&OsStr> for [S]

type Output = OsString

🔬This is a nightly-only experimental API. (slice_concat_trait #27747)

串联后的结果类型

fn join(slice: &Self, sep: &OsStr) -> OsString

🔬This is a nightly-only experimental API. (slice_concat_trait #27747)

[T]::join 的实现

impl<T, V> Join<&T> for [V]where T: Clone, V: Borrow<[T]>,

type Output = Vec<T, Global>

🔬This is a nightly-only experimental API. (slice_concat_trait #27747)

串联后的结果类型

fn join(slice: &[V], sep: &T) -> Vec<T, Global>

🔬This is a nightly-only experimental API. (slice_concat_trait #27747)

[T]::join 的实现

impl<S> Join<&str> for [S]where S: Borrow<str>,

type Output = String

🔬This is a nightly-only experimental API. (slice_concat_trait #27747)

串联后的结果类型

fn join(slice: &[S], sep: &str) -> String

🔬This is a nightly-only experimental API. (slice_concat_trait #27747)

[T]::join 的实现

impl<T> Ord for [T]where T: Ord,

实现 vectors 按字典顺序 的比较。

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

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

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

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

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

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

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

impl<T, U> PartialEq<&[U]> for Cow<'_, [T]>where T: PartialEq<U> + Clone,

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

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

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

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

impl<T, U, A> PartialEq<&[U]> for Vec<T, A>where A: Allocator, T: PartialEq<U>,

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

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

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

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

impl<T, U, A> PartialEq<&[U]> for VecDeque<T, A>where A: Allocator, T: PartialEq<U>,

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

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

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

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

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

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

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

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

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

impl<T, U> PartialEq<&mut [U]> for Cow<'_, [T]>where T: PartialEq<U> + Clone,

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

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

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

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

impl<T, U, A> PartialEq<&mut [U]> for Vec<T, A>where A: Allocator, T: PartialEq<U>,

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

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

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

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

impl<T, U, A> PartialEq<&mut [U]> for VecDeque<T, A>where A: Allocator, T: PartialEq<U>,

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<A, B> PartialEq<[B]> for [A]where A: PartialEq<B>,

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

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

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

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

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

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

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

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

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

impl<T, U, A> PartialEq<[U]> for Vec<T, A>where A: Allocator, T: PartialEq<U>,

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

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

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

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

impl<T, U, A> PartialEq<Vec<U, A>> for &[T]where A: Allocator, T: PartialEq<U>,

fn eq(&self, other: &Vec<U, A>) -> bool

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

fn ne(&self, other: &Vec<U, A>) -> bool

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

impl<T, U, A> PartialEq<Vec<U, A>> for &mut [T]where A: Allocator, T: PartialEq<U>,

fn eq(&self, other: &Vec<U, A>) -> bool

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

fn ne(&self, other: &Vec<U, A>) -> bool

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

impl<T, U, A> PartialEq<Vec<U, A>> for [T]where A: Allocator, T: PartialEq<U>,

fn eq(&self, other: &Vec<U, A>) -> bool

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

fn ne(&self, other: &Vec<U, A>) -> bool

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

impl<T> PartialOrd<[T]> for [T]where T: PartialOrd<T>,

实现 vectors 按字典顺序 的比较。

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

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

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

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

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

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

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

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

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

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

impl<'a, 'b> Pattern<'a> for &'b [char]

搜索等于切片中任何 char 的字符。

Examples

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

type Searcher = CharSliceSearcher<'a, 'b>

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

此模式的关联搜索者

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl Read for &[u8]

通过从切片复制为 &[u8] 实现读取。

请注意，读取将更新切片以指向尚未读取的部分。 到达 EOF 时，切片将为空。

fn read(&mut self, buf: &mut [u8]) -> Result<usize>

从该源中提取一些字节到指定的缓冲区中，返回读取的字节数。

fn read_buf(&mut self, cursor: BorrowedCursor<'_>) -> Result<()>

🔬This is a nightly-only experimental API. (read_buf #78485)

从此源中提取一些字节到指定的缓冲区中。

fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> Result<usize>

与 read 相似，不同之处在于它读入缓冲区的一部分。

fn is_read_vectored(&self) -> bool

🔬This is a nightly-only experimental API. (can_vector #69941)

确定此 Read 是否具有有效的 read_vectored 实现。

fn read_exact(&mut self, buf: &mut [u8]) -> Result<()>

读取填充 buf 所需的确切字节数。

fn read_to_end(&mut self, buf: &mut Vec<u8>) -> Result<usize>

读取所有字节，直到此源中的 EOF 为止，然后将它们放入 buf。

fn read_to_string(&mut self, buf: &mut String) -> Result<usize>

读取这个源中的所有字节，直到 EOF 为止，然后将它们追加到 buf。

fn read_buf_exact(&mut self, cursor: BorrowedCursor<'_>) -> Result<()>

🔬This is a nightly-only experimental API. (read_buf #78485)

读取填充 cursor 所需的确切字节数。

fn by_ref(&mut self) -> &mut Selfwhere Self: Sized,

为这个 Read 实例创建一个 “by reference” 适配器。

fn bytes(self) -> Bytes<Self> where Self: Sized,

将此 Read 实例的字节数转换为 Iterator。

fn chain<R: Read>(self, next: R) -> Chain<Self, R> where Self: Sized,

创建一个适配器，将这个流与另一个链接起来。

fn take(self, limit: u64) -> Take<Self> where Self: Sized,

创建一个适配器，最多从中读取 limit 个字节。

impl<T> SliceIndex<[T]> for (Bound<usize>, Bound<usize>)

type Output = [T]

方法返回的输出类型。

fn get( self, slice: &[T] ) -> Option<&<(Bound<usize>, Bound<usize>) as SliceIndex<[T]>>::Output>

🔬This is a nightly-only experimental API. (slice_index_methods)

如果在边界内，则返回此位置输出的共享引用。

fn get_mut( self, slice: &mut [T] ) -> Option<&mut <(Bound<usize>, Bound<usize>) as SliceIndex<[T]>>::Output>

🔬This is a nightly-only experimental API. (slice_index_methods)

如果在边界内，则对此位置的输出返回一个可变引用。

unsafe fn get_unchecked( self, slice: *const [T] ) -> *const <(Bound<usize>, Bound<usize>) as SliceIndex<[T]>>::Output

🔬This is a nightly-only experimental API. (slice_index_methods)

返回此位置输出的共享引用，而不执行任何边界检查。 即使未使用所得的引用，使用越界索引或悬垂的 slice 指针调用此方法也是 [undefined 行为]。

unsafe fn get_unchecked_mut( self, slice: *mut [T] ) -> *mut <(Bound<usize>, Bound<usize>) as SliceIndex<[T]>>::Output

🔬This is a nightly-only experimental API. (slice_index_methods)

返回此位置输出的变量引用，而不执行任何边界检查。 即使未使用所得的引用，使用越界索引或悬垂的 slice 指针调用此方法也是 [undefined 行为]。

fn index( self, slice: &[T] ) -> &<(Bound<usize>, Bound<usize>) as SliceIndex<[T]>>::Output

🔬This is a nightly-only experimental API. (slice_index_methods)

返回此位置输出的共享引用，如果越界则会触发 panic。

fn index_mut( self, slice: &mut [T] ) -> &mut <(Bound<usize>, Bound<usize>) as SliceIndex<[T]>>::Output

🔬This is a nightly-only experimental API. (slice_index_methods)

返回此位置输出的变量引用，如果越界则会触发 panic。

impl<T> SliceIndex<[T]> for Range<usize>

type Output = [T]

方法返回的输出类型。

fn get(self, slice: &[T]) -> Option<&[T]>

🔬This is a nightly-only experimental API. (slice_index_methods)

如果在边界内，则返回此位置输出的共享引用。

fn get_mut(self, slice: &mut [T]) -> Option<&mut [T]>

🔬This is a nightly-only experimental API. (slice_index_methods)

如果在边界内，则对此位置的输出返回一个可变引用。

unsafe fn get_unchecked(self, slice: *const [T]) -> *const [T]

🔬This is a nightly-only experimental API. (slice_index_methods)

返回此位置输出的共享引用，而不执行任何边界检查。 即使未使用所得的引用，使用越界索引或悬垂的 slice 指针调用此方法也是 [undefined 行为]。

unsafe fn get_unchecked_mut(self, slice: *mut [T]) -> *mut [T]

🔬This is a nightly-only experimental API. (slice_index_methods)

返回此位置输出的变量引用，而不执行任何边界检查。 即使未使用所得的引用，使用越界索引或悬垂的 slice 指针调用此方法也是 [undefined 行为]。

fn index(self, slice: &[T]) -> &[T]

🔬This is a nightly-only experimental API. (slice_index_methods)

返回此位置输出的共享引用，如果越界则会触发 panic。

fn index_mut(self, slice: &mut [T]) -> &mut [T]

🔬This is a nightly-only experimental API. (slice_index_methods)

返回此位置输出的变量引用，如果越界则会触发 panic。

impl<T> SliceIndex<[T]> for RangeFrom<usize>

type Output = [T]

方法返回的输出类型。

fn get(self, slice: &[T]) -> Option<&[T]>

🔬This is a nightly-only experimental API. (slice_index_methods)

如果在边界内，则返回此位置输出的共享引用。

fn get_mut(self, slice: &mut [T]) -> Option<&mut [T]>

🔬This is a nightly-only experimental API. (slice_index_methods)

如果在边界内，则对此位置的输出返回一个可变引用。

unsafe fn get_unchecked(self, slice: *const [T]) -> *const [T]

🔬This is a nightly-only experimental API. (slice_index_methods)

返回此位置输出的共享引用，而不执行任何边界检查。 即使未使用所得的引用，使用越界索引或悬垂的 slice 指针调用此方法也是 [undefined 行为]。

unsafe fn get_unchecked_mut(self, slice: *mut [T]) -> *mut [T]

🔬This is a nightly-only experimental API. (slice_index_methods)

返回此位置输出的变量引用，而不执行任何边界检查。 即使未使用所得的引用，使用越界索引或悬垂的 slice 指针调用此方法也是 [undefined 行为]。

fn index(self, slice: &[T]) -> &[T]

🔬This is a nightly-only experimental API. (slice_index_methods)

返回此位置输出的共享引用，如果越界则会触发 panic。

fn index_mut(self, slice: &mut [T]) -> &mut [T]

🔬This is a nightly-only experimental API. (slice_index_methods)

返回此位置输出的变量引用，如果越界则会触发 panic。

impl<T> SliceIndex<[T]> for RangeFull

type Output = [T]

方法返回的输出类型。

fn get(self, slice: &[T]) -> Option<&[T]>

🔬This is a nightly-only experimental API. (slice_index_methods)

如果在边界内，则返回此位置输出的共享引用。

fn get_mut(self, slice: &mut [T]) -> Option<&mut [T]>

🔬This is a nightly-only experimental API. (slice_index_methods)

如果在边界内，则对此位置的输出返回一个可变引用。

unsafe fn get_unchecked(self, slice: *const [T]) -> *const [T]

🔬This is a nightly-only experimental API. (slice_index_methods)

返回此位置输出的共享引用，而不执行任何边界检查。 即使未使用所得的引用，使用越界索引或悬垂的 slice 指针调用此方法也是 [undefined 行为]。

unsafe fn get_unchecked_mut(self, slice: *mut [T]) -> *mut [T]

🔬This is a nightly-only experimental API. (slice_index_methods)

返回此位置输出的变量引用，而不执行任何边界检查。 即使未使用所得的引用，使用越界索引或悬垂的 slice 指针调用此方法也是 [undefined 行为]。

fn index(self, slice: &[T]) -> &[T]

🔬This is a nightly-only experimental API. (slice_index_methods)

返回此位置输出的共享引用，如果越界则会触发 panic。

fn index_mut(self, slice: &mut [T]) -> &mut [T]

🔬This is a nightly-only experimental API. (slice_index_methods)

返回此位置输出的变量引用，如果越界则会触发 panic。

impl<T> SliceIndex<[T]> for RangeInclusive<usize>

type Output = [T]

方法返回的输出类型。

fn get(self, slice: &[T]) -> Option<&[T]>

🔬This is a nightly-only experimental API. (slice_index_methods)

如果在边界内，则返回此位置输出的共享引用。

fn get_mut(self, slice: &mut [T]) -> Option<&mut [T]>

🔬This is a nightly-only experimental API. (slice_index_methods)

如果在边界内，则对此位置的输出返回一个可变引用。

unsafe fn get_unchecked(self, slice: *const [T]) -> *const [T]

🔬This is a nightly-only experimental API. (slice_index_methods)

返回此位置输出的共享引用，而不执行任何边界检查。 即使未使用所得的引用，使用越界索引或悬垂的 slice 指针调用此方法也是 [undefined 行为]。

unsafe fn get_unchecked_mut(self, slice: *mut [T]) -> *mut [T]

🔬This is a nightly-only experimental API. (slice_index_methods)

返回此位置输出的变量引用，而不执行任何边界检查。 即使未使用所得的引用，使用越界索引或悬垂的 slice 指针调用此方法也是 [undefined 行为]。

fn index(self, slice: &[T]) -> &[T]

🔬This is a nightly-only experimental API. (slice_index_methods)

返回此位置输出的共享引用，如果越界则会触发 panic。

fn index_mut(self, slice: &mut [T]) -> &mut [T]

🔬This is a nightly-only experimental API. (slice_index_methods)

返回此位置输出的变量引用，如果越界则会触发 panic。

impl<T> SliceIndex<[T]> for RangeTo<usize>

type Output = [T]

方法返回的输出类型。

fn get(self, slice: &[T]) -> Option<&[T]>

🔬This is a nightly-only experimental API. (slice_index_methods)

如果在边界内，则返回此位置输出的共享引用。

fn get_mut(self, slice: &mut [T]) -> Option<&mut [T]>

🔬This is a nightly-only experimental API. (slice_index_methods)

如果在边界内，则对此位置的输出返回一个可变引用。

unsafe fn get_unchecked(self, slice: *const [T]) -> *const [T]

🔬This is a nightly-only experimental API. (slice_index_methods)

返回此位置输出的共享引用，而不执行任何边界检查。 即使未使用所得的引用，使用越界索引或悬垂的 slice 指针调用此方法也是 [undefined 行为]。

unsafe fn get_unchecked_mut(self, slice: *mut [T]) -> *mut [T]

🔬This is a nightly-only experimental API. (slice_index_methods)

返回此位置输出的变量引用，而不执行任何边界检查。 即使未使用所得的引用，使用越界索引或悬垂的 slice 指针调用此方法也是 [undefined 行为]。

fn index(self, slice: &[T]) -> &[T]

🔬This is a nightly-only experimental API. (slice_index_methods)

返回此位置输出的共享引用，如果越界则会触发 panic。

fn index_mut(self, slice: &mut [T]) -> &mut [T]

🔬This is a nightly-only experimental API. (slice_index_methods)

返回此位置输出的变量引用，如果越界则会触发 panic。

impl<T> SliceIndex<[T]> for RangeToInclusive<usize>

type Output = [T]

方法返回的输出类型。

fn get(self, slice: &[T]) -> Option<&[T]>

🔬This is a nightly-only experimental API. (slice_index_methods)

如果在边界内，则返回此位置输出的共享引用。

fn get_mut(self, slice: &mut [T]) -> Option<&mut [T]>

🔬This is a nightly-only experimental API. (slice_index_methods)

如果在边界内，则对此位置的输出返回一个可变引用。

unsafe fn get_unchecked(self, slice: *const [T]) -> *const [T]

🔬This is a nightly-only experimental API. (slice_index_methods)

返回此位置输出的共享引用，而不执行任何边界检查。 即使未使用所得的引用，使用越界索引或悬垂的 slice 指针调用此方法也是 [undefined 行为]。

unsafe fn get_unchecked_mut(self, slice: *mut [T]) -> *mut [T]

🔬This is a nightly-only experimental API. (slice_index_methods)

返回此位置输出的变量引用，而不执行任何边界检查。 即使未使用所得的引用，使用越界索引或悬垂的 slice 指针调用此方法也是 [undefined 行为]。

fn index(self, slice: &[T]) -> &[T]

🔬This is a nightly-only experimental API. (slice_index_methods)

返回此位置输出的共享引用，如果越界则会触发 panic。

fn index_mut(self, slice: &mut [T]) -> &mut [T]

🔬This is a nightly-only experimental API. (slice_index_methods)

返回此位置输出的变量引用，如果越界则会触发 panic。

impl<T> SliceIndex<[T]> for usize

type Output = T

方法返回的输出类型。

fn get(self, slice: &[T]) -> Option<&T>

🔬This is a nightly-only experimental API. (slice_index_methods)

如果在边界内，则返回此位置输出的共享引用。

fn get_mut(self, slice: &mut [T]) -> Option<&mut T>

🔬This is a nightly-only experimental API. (slice_index_methods)

如果在边界内，则对此位置的输出返回一个可变引用。

unsafe fn get_unchecked(self, slice: *const [T]) -> *const T

🔬This is a nightly-only experimental API. (slice_index_methods)

返回此位置输出的共享引用，而不执行任何边界检查。 即使未使用所得的引用，使用越界索引或悬垂的 slice 指针调用此方法也是 [undefined 行为]。

unsafe fn get_unchecked_mut(self, slice: *mut [T]) -> *mut T

🔬This is a nightly-only experimental API. (slice_index_methods)

返回此位置输出的变量引用，而不执行任何边界检查。 即使未使用所得的引用，使用越界索引或悬垂的 slice 指针调用此方法也是 [undefined 行为]。

fn index(self, slice: &[T]) -> &T

🔬This is a nightly-only experimental API. (slice_index_methods)

返回此位置输出的共享引用，如果越界则会触发 panic。

fn index_mut(self, slice: &mut [T]) -> &mut T

🔬This is a nightly-only experimental API. (slice_index_methods)

返回此位置输出的变量引用，如果越界则会触发 panic。

impl<T> SlicePattern for [T]

type Item = T

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

匹配的切片的元素类型。

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

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

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

impl<T> ToOwned for [T]where T: Clone,

type Owned = Vec<T, Global>

获得所有权后的结果类型。

fn to_owned(&self) -> Vec<T, Global>

从借用的数据创建拥有的数据，通常是通过克隆。

fn clone_into(&self, target: &mut Vec<T, Global>)

使用借来的数据来替换拥有的数据，通常是通过克隆。

impl<'a> ToSocketAddrs for &'a [SocketAddr]

type Iter = Cloned<Iter<'a, SocketAddr>>

在此类型可能对应的套接字地址上返回的迭代器。

fn to_socket_addrs(&self) -> Result<Self::Iter>

将此对象转换为已解析的 SocketAddr 的迭代器。

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

type Error = TryFromSliceError

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

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

执行转换。

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

type Error = TryFromSliceError

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

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

执行转换。

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

type Error = TryFromSliceError

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

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

执行转换。

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

type Error = TryFromSliceError

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

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

执行转换。

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

type Error = TryFromSliceError

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

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

执行转换。

impl<T, const N: usize> TryFrom<&mut [T]> for Simd<T, N>where LaneCount<N>: SupportedLaneCount, T: SimdElement,

type Error = TryFromSliceError

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

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

执行转换。

impl Write for &mut [u8]

通过将 &mut [u8] 复制到切片中并覆盖其数据来实现写入。

请注意，编写会更新切片以指向尚未编写的部分。 完全覆盖后，切片将为空。

如果要写入的字节数超过了切片的大小，则写入操作将返回短写入：最终为 Ok(0); 否则为 Ok(0)。在这种情况下，write_all 返回类型为 ErrorKind::WriteZero 的错误。

fn write(&mut self, data: &[u8]) -> Result<usize>

在此 writer 中写入一个缓冲区，返回写入的字节数。

fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> Result<usize>

类似于 write，不同之处在于它是从缓冲区切片中写入数据的。

fn is_write_vectored(&self) -> bool

🔬This is a nightly-only experimental API. (can_vector #69941)

确定此 Writer 是否具有有效的 write_vectored 实现。

fn write_all(&mut self, data: &[u8]) -> Result<()>

尝试将整个缓冲区写入此 writer。

fn flush(&mut self) -> Result<()>

刷新此输出流，确保所有中间缓冲的内容均到达其目的地。

fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> Result<()>

🔬This is a nightly-only experimental API. (write_all_vectored #70436)

尝试将多个缓冲区写入此 writer。

fn write_fmt(&mut self, fmt: Arguments<'_>) -> Result<()>

将格式化的字符串写入此 writer，返回遇到的任何错误。

fn by_ref(&mut self) -> &mut Selfwhere Self: Sized,

为这个 Write 实例创建一个 “by reference” 适配器。

impl<T> ConstParamTy for [T]where T: ConstParamTy,

impl<T> Eq for [T]where T: Eq,

impl<T> StructuralEq for [T]