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 类型的两倍。

另请参见 dynamically sized types 上的引用。

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

如果 a 或 b 越界，则为 Panics。

Examples

let mut v = ["a", "b", "c", "d"];
v.swap(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

返回由与 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_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, });
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 使用比较器函数搜索排序后的切片。

比较器函数应实现与基础切片的排序顺序一致的顺序，并返回指示其参数是所需目标的 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, });
Run

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, });
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, b 和 c），那么它就是一个总体顺序

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

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

let mut floats = [5f64, 4.0, 1.0, 3.0, 2.0];
floats.sort_unstable_by(|a, b| a.partial_cmp(b).unwrap());
assert_eq!(floats, [1.0, 2.0, 3.0, 4.0, 5.0]);
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 相同。

如果 T 实现 Copy，则使用 copy_from_slice 的性能可能更高。

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

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

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

Panics

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

Examples

在切片中复制四个字节:

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

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

assert_eq!(&bytes, b"Hello, Wello!");
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 及其后续元素 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());
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_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)));
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, b 和 c），那么它就是一个总体顺序

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

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

let mut floats = [5f64, 4.0, 1.0, 3.0, 2.0];
floats.sort_by(|a, b| a.partial_cmp(b).unwrap());
assert_eq!(floats, [1.0, 2.0, 3.0, 4.0, 5.0]);
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

创建一个可变的空切片。

创建一个空的切片。

将该值输入给定的 Hasher。 Read 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 lexicographically 的比较。

此方法返回 self 和 other 之间的 Ordering。 Read more

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

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

将值限制为一定的时间间隔。 Read more

此方法测试 self 和 other 值是否相等，并由 == 使用。 Read more

此方法测试 !=。

此方法测试 self 和 other 值是否相等，并由 == 使用。 Read more

此方法测试 !=。

此方法测试 self 和 other 值是否相等，并由 == 使用。 Read more

此方法测试 !=。

此方法测试 self 和 other 值是否相等，并由 == 使用。 Read more

此方法测试 !=。

此方法测试 self 和 other 值是否相等，并由 == 使用。 Read more

此方法测试 !=。

此方法测试 self 和 other 值是否相等，并由 == 使用。 Read more

此方法测试 !=。

此方法测试 self 和 other 值是否相等，并由 == 使用。 Read more

此方法测试 !=。

实现 vectors lexicographically 的比较。

如果存在，则此方法返回 self 和 other 值之间的顺序。 Read more

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

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

此方法测试大于 (对于 self 和 other)，并且由 > 操作员使用。 Read more

此方法测试是否大于或等于 (对于 self 和 other)，并且由 >= 运算符使用。 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

从 self 和 haystack 构造关联的搜索器以进行搜索。 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 为止，然后将它们放入 buf。 Read more

读取所有字节，直到该源中的 EOF 为止，然后将它们附加到 buf。 Read more

为此 Read 实例创建 “by reference” 适配器。 Read more

将此 Read 实例的字节数转换为 Iterator。 Read 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

将此 object 转换为解析的 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

获取 self 的 TypeId。 Read more

获取 self 的 TypeId。 Read more

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

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

从拥有的值中借用。 Read more

从拥有的值中借用。 Read more