Primitive Type slice1.0.0[]

Expand description

一个动态大小的视图到一个连续的序列,[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"];
Run

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

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

当切片存储所引用序列的长度时,它们的指针大小是 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]>>());
Run

Implementations

返回切片中的元素数。

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 = &mut [0, 1, 2];

if let Some(first) = x.first_mut() {
    *first = 5;
}
assert_eq!(x, &[5, 1, 2]);
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 = &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]);
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 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]);
Run

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

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

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

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

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

if let Some(last) = x.last_mut() {
    *last = 10;
}
assert_eq!(x, &[0, 1, 10]);
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) 或 None (如果索引越界),对元素或子切片返回可变引用。

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

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

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

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

Safety

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

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

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

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

有关安全的选择,请参见 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]);
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

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

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

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

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

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

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

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

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

在切片中交换两个元素。

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

如果 ab 越界,就会出现 panics。

Examples
let mut v = ["a", "b", "c", "d", "e"];
v.swap(2, 4);
assert!(v == ["a", "b", "e", "d", "c"]);
Run
🔬 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"]);
Run

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

Examples
let mut v = [1, 2, 3];
v.reverse();
assert!(v == [3, 2, 1]);
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

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

Examples
let x = &mut [1, 2, 4];
for elem in x.iter_mut() {
    *elem += 2;
}
assert_eq!(x, &[3, 4, 6]);
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

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

Panics

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

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

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

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

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

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

Panics

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

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]);
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. (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()` // 永远不允许零长度的块
Run
🔬 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]);
Run
🔬 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]);
Run
🔬 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]);
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

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

Panics

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

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

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

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

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

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

Panics

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

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

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

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

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

第一个将包含 [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]);
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. (slice_split_at_unchecked #76014)

new API

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

第一个将包含 [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]);
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
🔬 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 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]);
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 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]);
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 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]);
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 匹配的元素分隔,从切片的末尾开始并向后工作。 匹配的元素不包含在子切片中。

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

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

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

这种排序是不稳定的 (即可能重新排序相等的元素),就地 (即不分配) 和 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]);
Run

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

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

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

  • 完全和反对称的: a < ba == ba > b 之一正确,并且
  • 可传递的,a < bb < 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]);
Run
当前实现

当前算法基于 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]);
Run

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

这种排序是不稳定的 (即可能重新排序相等的元素),就地 (即不分配) 和 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]);
Run
👎 Deprecated since 1.49.0:

use the select_nth_unstable() instead

🔬 This is a nightly-only experimental API. (slice_partition_at_index #55300)

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

👎 Deprecated since 1.49.0:

use select_nth_unstable_by() instead

🔬 This is a nightly-only experimental API. (slice_partition_at_index #55300)

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

👎 Deprecated since 1.49.0:

use the select_nth_unstable_by_key() instead

🔬 This is a nightly-only experimental API. (slice_partition_at_index #55300)

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

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

此重新排序具有附加属性,即位置 i < index 处的任何值都将小于或等于位置 j > index 处的任何值。 此外,这种重新排序是不稳定的 (即 任何数量的相等元素都可以在位置 index 处就位 (即 不分配),以及 O(n) 最坏的情况。 在其他库中,该函数也被称为 “kth element”。 它返回以下值的三元组:所有元素在给定索引处小于一个,在给定索引处的值,以及所有在给定索引处大于一个的元素。

当前实现

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

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

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

此重排序具有附加属性,即使用比较器函数,位置 i < index 处的任何值将小于或等于位置 j > index 处的任何值。 另外,这种重新排序是不稳定的 (即,任意数量的相等元素可能会在位置 index 处结束),就地 (即,未分配) 和 O(n) 最坏的情况。 此函数在其他库中也称为 “kth element”。 它使用提供的比较器函数返回以下值的三元组:所有元素小于给定索引处的元素,给定索引处的值以及所有元素大于给定索引处的元素。

当前实现

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

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

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

此重新排序具有附加属性,即使用键提取函数,位置 i < index 处的任何值将小于或等于位置 j > index 处的任何值。 另外,这种重新排序是不稳定的 (即,任意数量的相等元素可能会在位置 index 处结束),就地 (即,未分配) 和 O(n) 最坏的情况。 此函数在其他库中也称为 “kth element”。 它使用提供的键提取函数返回以下值的三元组:所有元素小于给定索引处的元素,给定索引处的值以及所有元素大于给定索引处的元素。

当前实现

当前算法基于用于 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]);
Run
🔬 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]);
Run
🔬 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"]);
Run
🔬 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]);
Run

就地旋转切片,以使切片的第一个 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']);
Run

旋转子切片:

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

就地旋转切片,以使切片的第一个 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']);
Run

旋转子切片:

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

通过克隆 value,用元素填充 self

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

用重复调用闭包返回的元素填充 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]);
Run

将元素从 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]);
Run

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

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

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

要解决此问题,我们可以使用 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]);
Run

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

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

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

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

要解决此问题,我们可以使用 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]);
Run

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

srcself 内要复制的范围。 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!");
Run

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

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

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

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

要解决此问题,我们可以使用 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]);
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

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

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

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

当输入元素 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);
}
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) 相同,但不分配和复制临时文件。

将该切片原位转换为其 ASCII 大写形式。

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

要返回新的大写值而不修改现有值,请使用 to_ascii_uppercase

将该切片原位转换为其 ASCII 小写等效项。

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

要返回新的小写值而不修改现有值,请使用 to_ascii_lowercase

🔬 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

对切片进行排序。

这种排序是稳定的 (即,不对相等的元素重新排序),并且 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]);
Run

用比较器函数对切片进行排序。

这种排序是稳定的 (即,不对相等的元素重新排序),并且 O(n*log(* n*)) 最坏的情况)。

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

  • 完全和反对称的: a < ba == ba > b 之一正确,并且
  • 可传递的,a < bb < 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]);
Run

在适用时,首选不稳定排序,因为它通常比稳定排序快,并且不分配辅助内存。 请参见 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]);
Run

用键提取函数对切片进行排序。

这种排序是稳定的 (即,不对相等的元素重新排序),并且是 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]);
Run

用键提取函数对切片进行排序。

在排序期间,键函数每个元素仅被调用一次。

这种排序是稳定的 (即,不对相等的元素重新排序),并且 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]);
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

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

执行转换。

执行转换。

👎 Deprecated since 1.26.0:

use inherent methods instead

复制的 ASCII 字符的容器类型。

👎 Deprecated since 1.26.0:

use inherent methods instead

检查该值是否在 ASCII 范围内。 Read more

👎 Deprecated since 1.26.0:

use inherent methods instead

使值的副本等效于其 ASCII 大写字母。 Read more

👎 Deprecated since 1.26.0:

use inherent methods instead

以等效的 ASCII 小写形式复制值。 Read more

👎 Deprecated since 1.26.0:

use inherent methods instead

检查两个值是否为 ASCII 不区分大小写的匹配。 Read more

👎 Deprecated since 1.26.0:

use inherent methods instead

将此类型就地转换为其 ASCII 大写等效项。 Read more

👎 Deprecated since 1.26.0:

use inherent methods instead

将此类型就地转换为其 ASCII 小写等效项。 Read more

返回内部缓冲区的内容,如果内部缓冲区为空,则使用内部 reader 中的更多数据填充内部缓冲区。 Read more

告诉此缓冲区 amt 字节已从缓冲区中消耗掉,因此在调用 read 时不再应返回它们。 Read more

🔬 This is a nightly-only experimental API. (buf_read_has_data_left #86423)

recently added

检查底层 Read 是否有任何数据可供读取。 Read more

将所有字节读入 buf,直到到达定界符 byte 或 EOF。 Read more

读取所有字节,直到到达换行符 (0xA 字节),然后将它们追加到提供的缓冲区中。 Read more

返回对该字节 byte 上的 reader 拆分内容的迭代器。 Read more

返回此 reader 的各行上的迭代器。 Read more

🔬 This is a nightly-only experimental API. (slice_concat_trait #27747)

串联后的结果类型

🔬 This is a nightly-only experimental API. (slice_concat_trait #27747)

[T]::concat 的实现

Note: Concat<str> 中的 str 在这里没有意义。 trait 的这个类型参数的存在只是为了启用另一个 impl。

🔬 This is a nightly-only experimental API. (slice_concat_trait #27747)

串联后的结果类型

🔬 This is a nightly-only experimental API. (slice_concat_trait #27747)

[T]::concat 的实现

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

创建一个可变的空切片。

创建一个空的切片。

将该值输入给定的 HasherRead more

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

索引后返回的类型。

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

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

被迭代的元素的类型。

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

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

被迭代的元素的类型。

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

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

🔬 This is a nightly-only experimental API. (slice_concat_trait #27747)

串联后的结果类型

🔬 This is a nightly-only experimental API. (slice_concat_trait #27747)

[T]::join 的实现

🔬 This is a nightly-only experimental API. (slice_concat_trait #27747)

串联后的结果类型

🔬 This is a nightly-only experimental API. (slice_concat_trait #27747)

[T]::join 的实现

🔬 This is a nightly-only experimental API. (slice_concat_trait #27747)

串联后的结果类型

🔬 This is a nightly-only experimental API. (slice_concat_trait #27747)

[T]::join 的实现

实现 vectors 按字典顺序 的比较。

此方法返回 selfother 之间的 OrderingRead more

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

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

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

此方法测试 selfother 值是否相等,并由 == 使用。 Read more

此方法测试 !=

此方法测试 selfother 值是否相等,并由 == 使用。 Read more

此方法测试 !=

此方法测试 selfother 值是否相等,并由 == 使用。 Read more

此方法测试 !=

此方法测试 selfother 值是否相等,并由 == 使用。 Read more

此方法测试 !=

此方法测试 selfother 值是否相等,并由 == 使用。 Read more

此方法测试 !=

此方法测试 selfother 值是否相等,并由 == 使用。 Read more

此方法测试 !=

此方法测试 selfother 值是否相等,并由 == 使用。 Read more

此方法测试 !=

实现 vectors 按字典顺序 的比较。

如果存在,则此方法返回 selfother 值之间的顺序。 Read more

此方法测试的内容少于 (对于 selfother),并且由 < 操作员使用。 Read more

此方法测试小于或等于 (对于 selfother),并且由 <= 运算符使用。 Read more

此方法测试大于 (对于 selfother),并且由 > 操作员使用。 Read more

此方法测试是否大于或等于 (对于 selfother),并且由 >= 运算符使用。 Read more

搜索等于切片中任何 char 的字符。

Examples

assert_eq!("Hello world".find(&['l', 'l'] as &[_]), Some(2));
assert_eq!("Hello world".find(&['l', 'l'][..]), Some(2));
Run
🔬 This is a nightly-only experimental API. (pattern #27721)

API not fully fleshed out and ready to be stabilized

此模式的关联搜索者

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

API not fully fleshed out and ready to be stabilized

selfhaystack 构造关联的搜索器以进行搜索。 Read more

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

API not fully fleshed out and ready to be stabilized

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

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

API not fully fleshed out and ready to be stabilized

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

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

API not fully fleshed out and ready to be stabilized

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

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

API not fully fleshed out and ready to be stabilized

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

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

API not fully fleshed out and ready to be stabilized

如果匹配,则从 haystack 的后面删除模式。

通过从切片复制为 &[u8] 实现读取。

请注意,读取将更新切片以指向尚未读取的部分。 到达 EOF 时,切片将为空。

从该源中提取一些字节到指定的缓冲区中,返回读取的字节数。 Read more

read 相似,不同之处在于它读入缓冲区的一部分。 Read more

🔬 This is a nightly-only experimental API. (can_vector #69941)

确定此 Read 是否具有有效的 read_vectored 实现。 Read more

🔬 This is a nightly-only experimental API. (read_initializer #42788)

确定此 Reader 是否可以使用未初始化内存的缓冲区。 Read more

读取填充 buf 所需的确切字节数。 Read more

读取所有字节,直到此源中的 EOF 为止,然后将它们放入 bufRead more

读取这个源中的所有字节,直到 EOF 为止,然后将它们追加到 bufRead more

为这个 Read 实例创建一个基于引用的适配器。 Read more

将此 Read 实例的字节数转换为 IteratorRead more

创建一个适配器,将这个流与另一个链接起来。 Read more

创建一个适配器,最多从中读取 limit 个字节。 Read more

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

stopgap trait for slice patterns

匹配的切片的元素类型。

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

stopgap trait for slice patterns

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

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

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

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

recently added

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

在此类型可能对应的套接字地址上返回的迭代器。 Read more

将此对象转换为已解析的 SocketAddr 的迭代器。 Read more

通过将 &mut [u8] 复制到切片中并覆盖其数据来实现写入。

请注意,编写会更新切片以指向尚未编写的部分。 完全覆盖后,切片将为空。

如果要写入的字节数超过了切片的大小,则写入操作将返回短写入:最终为 Ok(0); 否则为 Ok(0)。在这种情况下,write_all 返回类型为 ErrorKind::WriteZero 的错误。

在此 writer 中写入一个缓冲区,返回写入的字节数。 Read more

类似于 write,不同之处在于它是从缓冲区切片中写入数据的。 Read more

🔬 This is a nightly-only experimental API. (can_vector #69941)

确定此 Writer 是否具有有效的 write_vectored 实现。 Read more

尝试将整个缓冲区写入此 writer。 Read more

刷新此输出流,确保所有中间缓冲的内容均到达其目的地。 Read more

🔬 This is a nightly-only experimental API. (write_all_vectored #70436)

尝试将多个缓冲区写入此 writer。 Read more

将格式化的字符串写入此 writer,返回遇到的任何错误。 Read more

为这个 Write 实例创建一个 “by reference” 适配器。 Read more

Auto Trait Implementations

Blanket Implementations

获取 selfTypeIdRead more

获取 selfTypeIdRead more

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

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

从拥有的值中借用。 Read more

从拥有的值中借用。 Read more