Struct std::io::IoSlice1.36.0[][src]

#[repr(transparent)]
pub struct IoSlice<'a>(_);
Expand description

Write::write_vectored 使用的缓冲区类型。

它在语义上是 &[u8] 的包装器,但保证与 Unix 平台上的 iovec 类型和 Windows 上的 WSABUF 类型的 ABI 兼容。

Implementations

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

Panics

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

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

前进切片的内部游标。

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

Examples
#![feature(io_slice_advance)]

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

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

// 将 3 个字节标记为已读。
buf.advance(3);
assert_eq!(buf.deref(), [1; 5].as_ref());
Run
🔬 This is a nightly-only experimental API. (io_slice_advance #62726)

前进切片的内部游标。

Notes

如果游标没有移到切片的末尾,则可以修改切片中的元素。 例如,如果我们有一个缓冲区切片,缓冲区的长度均为 2IoSlice',长度均为 8,并且将游标向前移动了 10 个字节,则第一个 IoSlice将保持不变,但是第二个IoSlice` 将被修改以删除前两个字节 (10-8)。

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

Methods from Deref<Target = [u8]>

返回切片中的元素数。

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  • 如果给定位置,则返回该位置上的元素的引用,如果越界则返回 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));
Run

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

有关安全的选择,请参见 get

Safety

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

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

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

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

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

调用者还必须确保指针 (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));
    }
}
Run

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

返回的范围是半开的,这意味着结束指针将 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));
Run

返回切片上的迭代器。

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

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

Panics

如果 size 为 0,就会出现 panics。

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

如果切片短于 size

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

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

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

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

Panics

如果 chunk_size 为 0,就会出现 panics。

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

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

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

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

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

Panics

如果 chunk_size 为 0,就会出现 panics。

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']);
Run
🔬 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()` // 永远不允许零长度的块
Run
🔬 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']);
Run
🔬 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']]);
Run
🔬 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']);
Run
🔬 This is a nightly-only experimental API. (array_windows #75027)

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

这是 windows 的 const 泛型等效项。

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

Panics

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

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

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

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

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

Panics

如果 chunk_size 为 0,就会出现 panics。

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

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

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

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

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

Panics

如果 chunk_size 为 0,就会出现 panics。

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

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

#![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);
Run

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

第一个将包含 [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, []);
}
Run
🔬 This is a nightly-only experimental API. (slice_split_at_unchecked #76014)

new API

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

第一个将包含 [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, []);
}
Run
🔬 This is a nightly-only experimental API. (split_array #90091)

new API

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

该数组将包含来自 [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, []);
}
Run

返回由与 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());
Run

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

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

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

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

返回由与 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());
Run

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

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

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

在子切片上返回一个迭代器,该迭代器由与 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);
Run

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

在子切片上返回一个迭代器,该子切片由与 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);
}
Run

在子切片上返回一个迭代器,该子切片由与 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);
}
Run

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

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

如果您没有 &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"));
Run

如果 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]));
Run

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

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

如果 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]));
Run

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

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

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

如果切片以 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()));
Run

返回删除后缀的子分片。

如果切片以 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);
Run

Binary 在排序后的切片中搜索给定的元素。

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

另请参见 binary_search_bybinary_search_by_keypartition_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, });
Run

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

let mut s = vec![0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55];
let num = 42;
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]);
Run

Binary 使用比较器函数搜索排序后的切片。

comparator 函数应该实现一个与底层切片的排序顺序一致的顺序,返回一个顺序代码,并指示其参数期望的目标是 LessEqual 还是 Greater

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

另请参见 binary_searchbinary_search_by_keypartition_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, });
Run

Binary 使用关键字提取函数搜索排序后的切片。

假定按关键字对切片进行排序,例如使用相同的关键字提取函数对 sort_by_key 进行排序。

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

另请参见 binary_searchbinary_search_bypartition_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, });
Run

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

此方法将切片分为三个不同的切片:前缀,正确对齐的新类型的中间切片和后缀切片。 该方法可以使中间切片对于给定类型和输入切片的最大长度成为可能,但是仅算法的性能应取决于此,而不取决于其正确性。

允许所有输入数据作为前缀或后缀切片返回。

当输入元素 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);
}
Run
🔬 This is a nightly-only experimental API. (is_sorted #53485)

new API

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

也就是说,对于每个元素 a 及其后续元素 ba <= 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());
Run
🔬 This is a nightly-only experimental API. (is_sorted #53485)

new API

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

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

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

new API

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

该函数将直接比较由 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()));
Run

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

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

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

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

另请参见 binary_searchbinary_search_bybinary_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)));
Run

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

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

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

🔬 This is a nightly-only experimental API. (inherent_ascii_escape #77174)

返回一个迭代器,该迭代器产生此转义版本的一个 ASCII 字符串,将其视为一个 ASCII 字符串。

Examples
#![feature(inherent_ascii_escape)]

let s = b"0\t\r\n'\"\\\x9d";
let escaped = s.escape_ascii().to_string();
assert_eq!(escaped, "0\\t\\r\\n\\'\\\"\\\\\\x9d");
Run

self 复制到新的 Vec 中。

Examples
let s = [10, 40, 30];
let x = s.to_vec();
// 在此,`s` 和 `x` 可以独立修改。
Run
🔬 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` 可以独立修改。
Run

通过重复切片 n 次来创建 vector。

Panics

如果容量溢出,此函数将为 panic。

Examples

基本用法:

assert_eq!([1, 2].repeat(3), vec![1, 2, 1, 2, 1, 2]);
Run

溢出时为 panic:

// 这将在运行时 panic
b"0123456789abcdef".repeat(usize::MAX);
Run

T 的切片展平为单个值 Self::Output

Examples
assert_eq!(["hello", "world"].concat(), "helloworld");
assert_eq!([[1, 2], [3, 4]].concat(), [1, 2, 3, 4]);
Run

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

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

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

要就地将值大写,请使用 make_ascii_uppercase

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

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

要就地小写该值,请使用 make_ascii_lowercase

Trait Implementations

返回值的副本。 Read more

source 执行复制分配。 Read more

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

解引用后的结果类型。

解引用值。

Auto Trait Implementations

Blanket Implementations

获取 selfTypeIdRead more

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

从拥有的值中借用。 Read more

执行转换。

执行转换。

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

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

🔬 This is a nightly-only experimental API. (toowned_clone_into #41263)

recently added

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

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

执行转换。

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

执行转换。