Struct std::io::IoSlice

impl<'a> IoSlice<'a>

pub fn new(buf: &'a [u8]) -> IoSlice<'a>

创建一个新的 IoSlice，包装一个字节切片。

Panics

如果切片大于 4GB，则在 Windows 上使用 panics。

pub fn advance(&mut self, n: usize)

🔬This is a nightly-only experimental API. (io_slice_advance #62726)

前进切片的内部游标。

另请参见 IoSlice::advance_slices 以推进多个缓冲区的游标。

Panics

试图超越切片末端时出现 panic。

Examples

#![feature(io_slice_advance)]

use std::io::IoSlice;
use std::ops::Deref;

let data = [1; 8];
let mut buf = IoSlice::new(&data);

// 将 3 个字节标记为已读。
buf.advance(3);
assert_eq!(buf.deref(), [1; 5].as_ref());

pub fn advance_slices(bufs: &mut &mut [IoSlice<'a>], n: usize)

🔬This is a nightly-only experimental API. (io_slice_advance #62726)

在 slices 中推进一个切片。

缩小切片以删除任何完全超前的 IoSlice。如果游标最终位于 IoSlice 的中间，则将其修改为从该游标处开始。

例如，如果我们有两个 8 字节的 IoSlice 的切片，并且我们提前 10 个字节，结果将只包括第二个 IoSlice，提前 2 个字节。

Panics

试图超越切片末端时出现 panic。

Examples

#![feature(io_slice_advance)]

use std::io::IoSlice;
use std::ops::Deref;

let buf1 = [1; 8];
let buf2 = [2; 16];
let buf3 = [3; 8];
let mut bufs = &mut [
    IoSlice::new(&buf1),
    IoSlice::new(&buf2),
    IoSlice::new(&buf3),
][..];

// 将 10 个字节标记为已写入。
IoSlice::advance_slices(&mut bufs, 10);
assert_eq!(bufs[0].deref(), [2; 14].as_ref());
assert_eq!(bufs[1].deref(), [3; 8].as_ref());

Methods from Deref<Target = [u8]>§

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

1.0.0 · source

pub fn len(&self) -> usize

返回切片中的元素数。

Examples

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

1.0.0 · source

pub fn is_empty(&self) -> bool

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

Examples

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

1.0.0 · source

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

1.5.0 · source

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

1.5.0 · source

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

1.0.0 · source

pub 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 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 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_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 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>());

1.0.0 · source

pub fn get(&self, index: I) -> Option<&>::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));

1.0.0 · source

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

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

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

Safety

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

Examples

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

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

1.0.0 · source

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

1.48.0 · source

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

1.0.0 · source

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

1.0.0 · source

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

1.0.0 · source

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

1.31.0 · source

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

1.31.0 · source

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

1.31.0 · source

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

1.0.0 · source

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

1.0.0 · source

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

1.51.0 · source

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

1.27.0 · source

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

1.0.0 · source

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:?}");
}

1.0.0 · source

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:?}");
}

1.0.0 · source

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

1.0.0 · source

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

1.0.0 · source

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

1.51.0 · source

pub fn strip_prefix(&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()));

1.51.0 · source

pub fn strip_suffix(&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);

1.0.0 · source

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

1.0.0 · source

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

1.10.0 · source

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

1.30.0 · source

pub unsafe fn align_to(&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 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 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()));

1.52.0 · source

pub fn partition_point(&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]);

1.23.0 · source

pub fn is_ascii(&self) -> bool

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

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

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

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

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

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

将此字节片段转换为 ASCII 字符片段，而不检查它们是否有效。

Safety

切片中的每个字节都必须在 0..=127 中，否则就是 UB。

1.23.0 · source

pub fn eq_ignore_ascii_case(&self, other: &[u8]) -> bool

检查两个片是否是 ASCII 大小写不敏感的匹配项。

与 to_ascii_lowercase(a) == to_ascii_lowercase(b) 相同，但不分配和复制临时文件。

1.60.0 · source

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

pub fn as_str(&self) -> &str

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

将这片 ASCII 字符视为 UTF-8 str。

pub fn as_bytes(&self) -> &[u8] ⓘ

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

将此 ASCII 字符片段视为 u8 字节片段。

1.23.0 · source

pub fn to_ascii_uppercase(&self) -> Vec<u8, Global> ⓘ

返回一个 vector，其中包含此切片的副本，其中每个字节都映射到其等效的 ASCII 大写字母。

ASCII 字母 ‘a’ 到 ‘z’ 映射到 ‘A’ 到 ‘Z’，但是非 ASCII 字母不变。

要就地将值大写，请使用 make_ascii_uppercase。

1.23.0 · source

pub fn to_ascii_lowercase(&self) -> Vec<u8, Global> ⓘ

返回一个 vector，其中包含该切片的副本，其中每个字节均映射为其等效的 ASCII 小写字母。

ASCII 字母 ‘A’ 到 ‘Z’ 映射到 ‘a’ 到 ‘z’，但是非 ASCII 字母不变。

要就地小写该值，请使用 make_ascii_lowercase。

1.0.0 · source

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` 可以独立修改。

1.40.0 · source

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

1.0.0 · source

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

1.3.0 · source

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

1.0.0 · source

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<'a> Clone for IoSlice<'a>

fn clone(&self) -> IoSlice<'a>

返回值的副本。 Read more

1.0.0 · source§

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

从 source 执行复制分配。 Read more

impl<'a> Debug for IoSlice<'a>

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

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

impl<'a> Deref for IoSlice<'a>

type Target = [u8]

解引用后的结果类型。

fn deref(&self) -> &[u8] ⓘ

解引用值。

impl<'a> Copy for IoSlice<'a>

1.44.0 · source§

impl<'a> Send for IoSlice<'a>

1.44.0 · source§

impl<'a> Sync for IoSlice<'a>

Auto Trait Implementations§

impl<'a> RefUnwindSafe for IoSlice<'a>

impl<'a> Unpin for IoSlice<'a>

impl<'a> UnwindSafe for IoSlice<'a>

Blanket Implementations§

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

fn type_id(&self) -> TypeId

获取 self 的 TypeId。 Read more

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

fn borrow(&self) -> &T

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

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

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

从拥有的值中借用。 Read more

impl<T> From<T> for T

fn from(t: T) -> T

返回未更改的参数。

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

fn into(self) -> U

调用 U::from(self)。

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

impl<T> ToOwned for Twhere T: Clone,

type Owned = T

获得所有权后的结果类型。

fn to_owned(&self) -> T

从借用的数据创建拥有的数据，通常是通过克隆。 Read more

fn clone_into(&self, target: &mut T)

使用借来的数据来替换拥有的数据，通常是通过克隆。 Read more

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

type Error = Infallible

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

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

执行转换。

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

type Error = >::Error

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