Struct std::string::String

pub struct String { /* private fields */ }

一个 UTF-8 编码的可增长字符串。

String 类型是最常见的字符串类型，拥有对该字符串内容的所有权。它与其借用的对应物，原始的 str 有着密切的关系。

Examples

您可以使用 String::from 从一个 字符串字面量 创建一个 String：

let hello = String::from("Hello, world!");

您可以使用 push 方法将 char 追加到 String 上，并使用 push_str 方法追加 &str：

let mut hello = String::from("Hello, ");

hello.push('w');
hello.push_str("orld!");

如果具有 UTF-8 字节的 vector，则可以使用 from_utf8 方法从中创建一个 String：

// vector 中的一些字节
let sparkle_heart = vec![240, 159, 146, 150];

// 我们知道这些字节是有效的，因此我们将使用 `unwrap()`。
let sparkle_heart = String::from_utf8(sparkle_heart).unwrap();

assert_eq!("💖", sparkle_heart);

UTF-8

Strings 始终是有效的 UTF-8。如果您需要非 UTF-8 字符串，请考虑 OsString。它是相似的，但是没有 UTF-8 约束。因为 UTF-8 是可变宽度的编码，Strings 通常小于相同 chars 的数组:

use std::mem;

// `s` 是 ASCII 码，它表示每个 `char` 为一个字节
let s = "hello";
assert_eq!(s.len(), 5);

// 具有相同内容的 `char` 数组会更长，因为每个 `char` 都是四个字节
let s = ['h', 'e', 'l', 'l', 'o'];
let size: usize = s.into_iter().map(|c| mem::size_of_val(&c)).sum();
assert_eq!(size, 20);

// 但是，对于非 ASCII 字符串，差异会更小，有时它们是相同的
let s = "💖💖💖💖💖";
assert_eq!(s.len(), 20);

let s = ['💖', '💖', '💖', '💖', '💖'];
let size: usize = s.into_iter().map(|c| mem::size_of_val(&c)).sum();
assert_eq!(size, 20);

这就提出了一些有趣的问题，比如 s[i] 应该如何工作。 i 在这里应该是什么? 几个选项包括字节索引和 char 索引，但由于 UTF-8 编码，只有字节索引会提供时间特性索引。例如，可以使用 chars 获取第 i 个 char:

let s = "hello";
let third_character = s.chars().nth(2);
assert_eq!(third_character, Some('l'));

let s = "💖💖💖💖💖";
let third_character = s.chars().nth(2);
assert_eq!(third_character, Some('💖'));

接下来，s[i] 应该返回什么? 因为索引会返回对，底层，数据的引用，所以它可能是 &u8、&[u8] 或其他类似的东西。 由于我们只提供一个索引，&u8 是最有意义的，但这可能不是用户所期望的，并且可以通过 as_bytes():

// 第一个字节是 104-`'h'` 的字节值
let s = "hello";
assert_eq!(s.as_bytes()[0], 104);
// or
assert_eq!(s.as_bytes()[0], b'h');

// 第一个字节是 240 这显然没有用
let s = "💖💖💖💖💖";
assert_eq!(s.as_bytes()[0], 240);

由于这些歧义或限制，简单地禁止使用 usize 进行索引:

let s = "hello";

// 以下内容将不会编译!
println!("The first letter of s is {}", s[0]);

然而，更清楚的是 &s[i..j] 应该如何工作 (即，使用范围进行索引)。它应该接受字节索引 (作为特征时间) 并返回一个 &str，它是 UTF-8 编码的。这也称为 “字符串切片”。 请注意，如果提供的字节索引不是字符边界，这将导致 panic - 有关更多详细信息，请参见 is_char_boundary。有关字符串切片的更多详细信息，请参见 SliceIndex<str> 的实现。有关字符串切片的非 panic 版本，请参见 get。

bytes 和 chars 方法分别返回字符串的字节和代码点的迭代器。要迭代代码点和字节索引，请使用 char_indices。

Deref

String 实现了 Deref<Target = str>，因此继承了 str 的所有方法。另外，这意味着您可以使用与号 (&) 将 String 传递给采用 &str 的函数：

fn takes_str(s: &str) { }

let s = String::from("Hello");

takes_str(&s);

这将从 String 创建一个 &str，并将其传入。这种转换非常便宜，因此通常，函数会接受 &str 作为参数，除非出于某些特定原因它们需要 String。

在某些情况下，Rust 没有足够的信息来进行此转换，称为 Deref 强制多态。在以下示例中，字符串切片 &'a str 实现 TraitExample trait，函数 example_func 接受实现 trait 的所有内容。 在这种情况下，Rust 将需要进行两次隐式转换，而 Rust 没有办法进行转换。 因此，以下示例将无法编译。

trait TraitExample {}

impl<'a> TraitExample for &'a str {}

fn example_func<A: TraitExample>(example_arg: A) {}

let example_string = String::from("example_string");
example_func(&example_string);

有两种选择可以代替。第一种是使用方法 as_str() 显式提取包含该字符串的字符串切片，从而将 example_func(&example_string); 行更改为 example_func(example_string.as_str());。 第二种方法将 example_func(&example_string); 更改为 example_func(&*example_string);。 在这种情况下，我们将 String 解引用到 str，然后将 str 引用回 &str。 第二种方法更惯用，但是两种方法都可以显式地进行转换，而不是依赖于隐式转换。

Representation

String 由三个部分组成：指向某些字节的指针，长度和容量。指针指向 String 用于存储其数据的内部缓冲区。长度是当前存储在缓冲区中的字节数，容量是缓冲区的大小 (以字节为单位)。

这样，长度将始终小于或等于容量。

此缓冲区始终存储在堆中。

您可以使用 as_ptr，len 和 capacity 方法查看它们：

use std::mem;

let story = String::from("Once upon a time...");

// 防止自动丢弃字符串的数据
let mut story = mem::ManuallyDrop::new(story);

let ptr = story.as_mut_ptr();
let len = story.len();
let capacity = story.capacity();

// story 有十九个字节
assert_eq!(19, len);

// 我们可以用 ptr，len 和 capacity 重新构建一个 String。
// 这都是不安全的，因为我们有责任确保组件有效：
let s = unsafe { String::from_raw_parts(ptr, len, capacity) } ;

assert_eq!(String::from("Once upon a time..."), s);

如果 String 具有足够的容量，则向其添加元素将不会重新分配。例如，考虑以下程序：

let mut s = String::new();

println!("{}", s.capacity());

for _ in 0..5 {
    s.push_str("hello");
    println!("{}", s.capacity());
}

这将输出以下内容：

0
8
16
16
32
32

最初，我们根本没有分配任何内存，但是当我们追加到字符串后，它会适当地增加其容量。如果我们改为使用 with_capacity 方法来初始分配正确的容量，请执行以下操作：

let mut s = String::with_capacity(25);

println!("{}", s.capacity());

for _ in 0..5 {
    s.push_str("hello");
    println!("{}", s.capacity());
}

我们最终得到了不同的输出：

25
25
25
25
25
25

在这里，不需要在循环内分配更多的内存。

Implementations

impl String

pub const fn new() -> String

创建一个新的空 String。

由于 String 为空，因此不会分配任何初始缓冲区。虽然这意味着该初始操作非常便宜，但在以后添加数据时可能会导致过多的分配。

如果您对 String 可以容纳多少数据有所了解，请考虑使用 with_capacity 方法来防止过多的重新分配。

Examples

基本用法：

let s = String::new();

pub fn with_capacity(capacity: usize) -> String

创建一个至少具有指定容量的新空 String。

String 有一个内部缓冲区来保存其数据。 容量是该缓冲区的长度，可以使用 capacity 方法进行查询。 此方法创建一个空的 String，但它的初始缓冲区至少可容纳 capacity 字节。 当您可能将一堆数据追加到 String 时，这很有用，从而减少了它需要进行的重新分配的次数。

如果给定的容量为 0，则不会进行分配，并且此方法与 new 方法相同。

Examples

基本用法：

let mut s = String::with_capacity(10);

// 字符串不包含任何字符，即使它可以容纳更多字符
assert_eq!(s.len(), 0);

// 这些都是在不重新分配的情况下完成的...
let cap = s.capacity();
for _ in 0..10 {
    s.push('a');
}

assert_eq!(s.capacity(), cap);

// ...但这可能会使字符串重新分配
s.push('a');

pub fn from_utf8(vec: Vec<u8, Global>) -> Result<String, FromUtf8Error>

将字节的 vector 转换为 String。

字符串 (String) 由字节 (u8) 组成，字节 (Vec<u8>) 的 vector 由字节组成，因此此函数在两者之间进行转换。 并非所有的字节片都是有效的 String，但是: String 要求它是有效的 UTF-8。 from_utf8() 检查以确保字节是有效的 UTF-8，然后进行转换。

如果您确定字节切片是有效的 UTF-8，并且不想增加有效性检查的开销，则此函数有一个不安全的版本 from_utf8_unchecked，它具有相同的行为，但是会跳过检查。

为了提高效率，此方法将注意不要复制 vector。

如果需要 &str 而不是 String，请考虑使用 str::from_utf8。

与此方法的相反的是 into_bytes。

Errors

如果切片不是 UTF-8，则返回 Err，并说明为什么提供的字节不是 UTF-8。还包括您移入的 vector。

Examples

基本用法：

// vector 中的一些字节
let sparkle_heart = vec![240, 159, 146, 150];

// 我们知道这些字节是有效的，因此我们将使用 `unwrap()`。
let sparkle_heart = String::from_utf8(sparkle_heart).unwrap();

assert_eq!("💖", sparkle_heart);

字节不正确：

// vector 中的一些无效字节
let sparkle_heart = vec![0, 159, 146, 150];

assert!(String::from_utf8(sparkle_heart).is_err());

请参见 FromUtf8Error 文档，以获取有关此错误的更多详细信息。

pub fn from_utf8_lossy(v: &[u8]) -> Cow<'_, str>

将字节切片转换为字符串，包括无效字符。

字符串由字节 (u8) 组成，而字节 (&[u8]) 的切片由字节组成，因此此函数在两者之间进行转换。然而，并非所有的字节片都是有效的字符串，字符串必须是有效的 UTF-8。 在此转换过程中，from_utf8_lossy() 会将所有无效的 UTF-8 序列替换为 U+FFFD REPLACEMENT CHARACTER，如下所示：

如果您确定字节切片是有效的 UTF-8，并且不想增加转换的开销，则此函数有一个不安全的版本 from_utf8_unchecked，它具有相同的行为，但是会跳过检查。

此函数返回 Cow<'a, str>。如果字节切片的 UTF-8 无效，则需要插入替换字符，这将更改字符串的大小，因此需要 String。 但是，如果它已经是有效的 UTF-8，则不需要新的分配。 这种返回类型使我们能够处理两种情况。

Examples

基本用法：

// vector 中的一些字节
let sparkle_heart = vec![240, 159, 146, 150];

let sparkle_heart = String::from_utf8_lossy(&sparkle_heart);

assert_eq!("💖", sparkle_heart);

字节不正确：

// 一些无效的字节
let input = b"Hello \xF0\x90\x80World";
let output = String::from_utf8_lossy(input);

assert_eq!("Hello �World", output);

pub fn from_utf16(v: &[u16]) -> Result<String, FromUtf16Error>

将 UTF-16 编码的 vector v 解码为 String，如果 v 包含任何无效数据，则返回 Err。

Examples

基本用法：

// 𝄞music
let v = &[0xD834, 0xDD1E, 0x006d, 0x0075,
          0x0073, 0x0069, 0x0063];
assert_eq!(String::from("𝄞music"),
           String::from_utf16(v).unwrap());

// 𝄞mu<invalid>ic
let v = &[0xD834, 0xDD1E, 0x006d, 0x0075,
          0xD800, 0x0069, 0x0063];
assert!(String::from_utf16(v).is_err());

pub fn from_utf16_lossy(v: &[u16]) -> String

将 UTF-16 编码的切片 v 解码为 String，将无效数据替换为 替换字符 (U+FFFD)。

与 from_utf8_lossy 返回 Cow<'a, str> 不同，from_utf16_lossy 返回 String，因为 UTF-16 到 UTF-8 的转换需要分配内存。

Examples

基本用法：

// 𝄞mus<invalid>ic<invalid>
let v = &[0xD834, 0xDD1E, 0x006d, 0x0075,
          0x0073, 0xDD1E, 0x0069, 0x0063,
          0xD834];

assert_eq!(String::from("𝄞mus\u{FFFD}ic\u{FFFD}"),
           String::from_utf16_lossy(v));

pub fn into_raw_parts(self) -> (*mut u8, usize, usize)

🔬This is a nightly-only experimental API. (vec_into_raw_parts #65816)

将 String 分解为其原始组件。

返回指向底层数据的裸指针，字符串的长度 (以字节为单位) 和数据的已分配容量 (以字节为单位)。 这些参数与 from_raw_parts 的参数顺序相同。

调用此函数后，调用者将负责先前由 String 管理的内存。 唯一的方法是使用 from_raw_parts 函数将裸指针，长度和容量转换回 String，从而允许析构函数执行清除操作。

Examples

#![feature(vec_into_raw_parts)]
let s = String::from("hello");

let (ptr, len, cap) = s.into_raw_parts();

let rebuilt = unsafe { String::from_raw_parts(ptr, len, cap) };
assert_eq!(rebuilt, "hello");

pub unsafe fn from_raw_parts( buf: *mut u8, length: usize, capacity: usize ) -> String

根据长度，容量和指针创建一个新的 String。

Safety

这是非常不安全的，因为没有检查的不变量的数量：

• buf 处的内存需要由标准库使用的同一分配器预先分配，并且需要精确对齐 1.
• length 需要小于或等于 capacity。
• capacity 需要是正确的值。
• buf 的前 length 字节必须为有效的 UTF-8。

违反这些可能会导致一些问题，比如破坏分配器的内部数据结构。 例如，从指向包含 UTF-8 的 C char 数组的指针构建 String 通常不安全，除非您确定该数组最初是由 Rust 标准库的分配器分配的。

buf 的所有权有效地转移到 String，然后 String 可以随意释放，重新分配或更改指针所指向的内存的内容。 调用此函数后，请确保没有其他任何东西使用该指针。

Examples

基本用法：

use std::mem;

unsafe {
    let s = String::from("hello");

    // 防止自动丢弃字符串的数据
    let mut s = mem::ManuallyDrop::new(s);

    let ptr = s.as_mut_ptr();
    let len = s.len();
    let capacity = s.capacity();

    let s = String::from_raw_parts(ptr, len, capacity);

    assert_eq!(String::from("hello"), s);
}

pub unsafe fn from_utf8_unchecked(bytes: Vec<u8, Global>) -> String

将字节的 vector 转换为 String，而无需检查字符串是否包含有效的 UTF-8。

有关更多详细信息，请参见安全版本 from_utf8。

Safety

此函数不安全，因为它不检查传递给它的字节是否为有效的 UTF-8。 如果违反了此约束，则 String 的未来用户可能会导致内存不安全问题，因为标准库的其余部分都假定 String 是有效的 UTF-8。

Examples

基本用法：

// vector 中的一些字节
let sparkle_heart = vec![240, 159, 146, 150];

let sparkle_heart = unsafe {
    String::from_utf8_unchecked(sparkle_heart)
};

assert_eq!("💖", sparkle_heart);

pub fn into_bytes(self) -> Vec<u8, Global>

将 String 转换为字节 vector。

这会消耗 String，因此我们不需要复制其内容。

Examples

基本用法：

let s = String::from("hello");
let bytes = s.into_bytes();

assert_eq!(&[104, 101, 108, 108, 111][..], &bytes[..]);

pub fn as_str(&self) -> &str

提取包含整个 String 的字符串切片。

Examples

基本用法：

let s = String::from("foo");

assert_eq!("foo", s.as_str());

pub fn as_mut_str(&mut self) -> &mut str

将 String 转换为可变字符串切片。

Examples

基本用法：

let mut s = String::from("foobar");
let s_mut_str = s.as_mut_str();

s_mut_str.make_ascii_uppercase();

assert_eq!("FOOBAR", s_mut_str);

pub fn push_str(&mut self, string: &str)

将给定的字符串切片追加到这个 String 的末尾。

Examples

基本用法：

let mut s = String::from("foo");

s.push_str("bar");

assert_eq!("foobar", s);

pub fn extend_from_within<R>(&mut self, src: R)where R: RangeBounds<usize>,

🔬This is a nightly-only experimental API. (string_extend_from_within #103806)

将 src 范围内的元素复制到字符串的末尾。

Panics

如果起始点或结束点不在 char 边界上，或超出边界，就会出现 panic。

Examples

#![feature(string_extend_from_within)]
let mut string = String::from("abcde");

string.extend_from_within(2..);
assert_eq!(string, "abcdecde");

string.extend_from_within(..2);
assert_eq!(string, "abcdecdeab");

string.extend_from_within(4..8);
assert_eq!(string, "abcdecdeabecde");

pub fn capacity(&self) -> usize

返回此字符串的容量 (以字节为单位)。

Examples

基本用法：

let s = String::with_capacity(10);

assert!(s.capacity() >= 10);

pub fn reserve(&mut self, additional: usize)

保留至少比当前长度多 additional 字节的容量。分配器可以保留更多空间来推测性地避免频繁分配。

调用 reserve 后，容量将大于或等于 self.len() + additional。 如果容量已经足够，则不执行任何操作。

Panics

如果新容量溢出 usize，就会出现 panics。

Examples

基本用法：

let mut s = String::new();

s.reserve(10);

assert!(s.capacity() >= 10);

这实际上可能不会增加容量：

let mut s = String::with_capacity(10);
s.push('a');
s.push('b');

// s 现在的长度为 2，容量至少为 10
let capacity = s.capacity();
assert_eq!(2, s.len());
assert!(capacity >= 10);

// 因为我们已经至少有额外的 8 个容量，所以称这个...
s.reserve(8);

// ... 实际上并没有增加。
assert_eq!(capacity, s.capacity());

pub fn reserve_exact(&mut self, additional: usize)

保留至少比当前长度多 additional 字节的最小容量。 与 reserve 不同，这不会故意过度分配以推测性地避免频繁分配。

调用 reserve_exact 后，容量将大于或等于 self.len() + additional。 如果容量已经足够，则不执行任何操作。

Panics

如果新容量溢出 usize，就会出现 panics。

Examples

基本用法：

let mut s = String::new();

s.reserve_exact(10);

assert!(s.capacity() >= 10);

这实际上可能不会增加容量：

let mut s = String::with_capacity(10);
s.push('a');
s.push('b');

// s 现在的长度为 2，容量至少为 10
let capacity = s.capacity();
assert_eq!(2, s.len());
assert!(capacity >= 10);

// 因为我们已经至少有额外的 8 个容量，所以称这个...
s.reserve_exact(8);

// ... 实际上并没有增加。
assert_eq!(capacity, s.capacity());

pub fn try_reserve(&mut self, additional: usize) -> Result<(), TryReserveError>

尝试为至少比当前长度多 additional 字节的容量保留容量。 分配器可以保留更多空间来推测性地避免频繁分配。 调用 try_reserve 后，如果返回 Ok(())，容量将大于等于 self.len() + additional。

如果容量已经足够，则不执行任何操作。 即使发生错误，此方法也会保留内容。

Errors

如果容量溢出，或者分配器报告失败，则返回错误。

Examples

use std::collections::TryReserveError;

fn process_data(data: &str) -> Result<String, TryReserveError> {
    let mut output = String::new();

    // 预先保留内存，如果不能，则退出
    output.try_reserve(data.len())?;

    // 现在我们知道在我们复杂的工作中这不能 OOM
    output.push_str(data);

    Ok(output)
}

pub fn try_reserve_exact( &mut self, additional: usize ) -> Result<(), TryReserveError>

尝试为至少比当前长度多 additional 字节的最小容量保留。 与 try_reserve 不同，这不会故意过度分配以推测性地避免频繁分配。 调用 try_reserve_exact 后，如果返回 Ok(())，则容量将大于或等于 self.len() + additional。

如果容量已经足够，则不执行任何操作。

请注意，分配器可能会给集合提供比其请求更多的空间。 因此，不能依靠容量来精确地最小化。 如果希望将来插入，则首选 try_reserve。

Errors

如果容量溢出，或者分配器报告失败，则返回错误。

Examples

use std::collections::TryReserveError;

fn process_data(data: &str) -> Result<String, TryReserveError> {
    let mut output = String::new();

    // 预先保留内存，如果不能，则退出
    output.try_reserve_exact(data.len())?;

    // 现在我们知道在我们复杂的工作中这不能 OOM
    output.push_str(data);

    Ok(output)
}

pub fn shrink_to_fit(&mut self)

缩小此 String 的容量以使其长度匹配。

Examples

基本用法：

let mut s = String::from("foo");

s.reserve(100);
assert!(s.capacity() >= 100);

s.shrink_to_fit();
assert_eq!(3, s.capacity());

pub fn shrink_to(&mut self, min_capacity: usize)

降低 String 的容量。

容量将至少保持与长度和提供的值一样大。

如果当前容量小于下限，则为无操作。

Examples

let mut s = String::from("foo");

s.reserve(100);
assert!(s.capacity() >= 100);

s.shrink_to(10);
assert!(s.capacity() >= 10);
s.shrink_to(0);
assert!(s.capacity() >= 3);

pub fn push(&mut self, ch: char)

将给定的 char 追加到该 String 的末尾。

Examples

基本用法：

let mut s = String::from("abc");

s.push('1');
s.push('2');
s.push('3');

assert_eq!("abc123", s);

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

返回此 String 内容的字节切片。

与此方法的相反的是 from_utf8。

Examples

基本用法：

let s = String::from("hello");

assert_eq!(&[104, 101, 108, 108, 111], s.as_bytes());

pub fn truncate(&mut self, new_len: usize)

将此 String 缩短为指定的长度。

如果 new_len 大于字符串的当前长度，则无效。

请注意，此方法对字符串的分配容量没有影响

Panics

如果 new_len 不位于 char 边界上，就会出现 panics。

Examples

基本用法：

let mut s = String::from("hello");

s.truncate(2);

assert_eq!("he", s);

pub fn pop(&mut self) -> Option<char>

从字符串缓冲区中删除最后一个字符并返回它。

如果 String 为空，则返回 None。

Examples

基本用法：

let mut s = String::from("foo");

assert_eq!(s.pop(), Some('o'));
assert_eq!(s.pop(), Some('o'));
assert_eq!(s.pop(), Some('f'));

assert_eq!(s.pop(), None);

pub fn remove(&mut self, idx: usize) -> char

从该 String 的字节位置删除 char 并将其返回。

这是 O(n) 操作，因为它需要复制缓冲区中的每个元素。

Panics

如果 idx 大于或等于 String 的长度，或者它不位于 char 边界上，就会出现 panics。

Examples

基本用法：

let mut s = String::from("foo");

assert_eq!(s.remove(0), 'f');
assert_eq!(s.remove(1), 'o');
assert_eq!(s.remove(0), 'o');

pub fn remove_matches<P, 'a>(&'a mut self, pat: P)where P: for<'x> Pattern<'x>,

🔬This is a nightly-only experimental API. (string_remove_matches #72826)

删除 String 中所有模式 pat 的匹配项。

Examples

#![feature(string_remove_matches)]
let mut s = String::from("Trees are not green, the sky is not blue.");
s.remove_matches("not ");
assert_eq!("Trees are green, the sky is blue.", s);

匹配项将被检测并迭代删除，因此在样式重叠的情况下，仅第一个样式将被删除：

#![feature(string_remove_matches)]
let mut s = String::from("banana");
s.remove_matches("ana");
assert_eq!("bna", s);

pub fn retain<F>(&mut self, f: F)where F: FnMut(char) -> bool,

仅保留谓词指定的字符。

换句话说，删除所有字符 c，以使 f(c) 返回 false。 此方法在原地运行，以原始顺序恰好一次访问每个字符，并保留保留字符的顺序。

Examples

let mut s = String::from("f_o_ob_ar");

s.retain(|c| c != '_');

assert_eq!(s, "foobar");

由于按原始顺序仅对元素进行过一次访问，因此可以使用外部状态来确定要保留哪些元素。

let mut s = String::from("abcde");
let keep = [false, true, true, false, true];
let mut iter = keep.iter();
s.retain(|_| *iter.next().unwrap());
assert_eq!(s, "bce");

pub fn insert(&mut self, idx: usize, ch: char)

在此 String 的字节位置插入一个字符。

这是一个 O(n) 操作，因为它需要复制缓冲区中的每个元素。

Panics

如果 idx 大于 String 的长度，或者它不在 char 边界上，就会出现 panics。

Examples

基本用法：

let mut s = String::with_capacity(3);

s.insert(0, 'f');
s.insert(1, 'o');
s.insert(2, 'o');

assert_eq!("foo", s);

pub fn insert_str(&mut self, idx: usize, string: &str)

在此 String 的字节位置处插入字符串切片。

这是一个 O(n) 操作，因为它需要复制缓冲区中的每个元素。

Panics

如果 idx 大于 String 的长度，或者它不在 char 边界上，就会出现 panics。

Examples

基本用法：

let mut s = String::from("bar");

s.insert_str(0, "foo");

assert_eq!("foobar", s);

pub unsafe fn as_mut_vec(&mut self) -> &mut Vec<u8, Global>

返回此 String 的内容的可变引用。

Safety

这个函数是不安全的，因为返回的 &mut Vec 允许写入无效的 UTF-8 字节。 如果违反此约束，则在丢弃 &mut Vec 之后使用原始 String 可能会违反内存安全，因为标准库的其余部分假定 String 是有效的 UTF-8。

Examples

基本用法：

let mut s = String::from("hello");

unsafe {
    let vec = s.as_mut_vec();
    assert_eq!(&[104, 101, 108, 108, 111][..], &vec[..]);

    vec.reverse();
}
assert_eq!(s, "olleh");

pub fn len(&self) -> usize

返回此 String 的长度，以字节为单位，而不是 char 或字素。 换句话说，它可能不是人类认为的字符串长度。

Examples

基本用法：

let a = String::from("foo");
assert_eq!(a.len(), 3);

let fancy_f = String::from("ƒoo");
assert_eq!(fancy_f.len(), 4);
assert_eq!(fancy_f.chars().count(), 3);

pub fn is_empty(&self) -> bool

如果此 String 的长度为零，则返回 true，否则返回 false。

Examples

基本用法：

let mut v = String::new();
assert!(v.is_empty());

v.push('a');
assert!(!v.is_empty());

pub fn split_off(&mut self, at: usize) -> String

在给定的字节索引处将字符串拆分为两个。

返回新分配的 String。 self 包含字节 [0, at)，返回的 String 包含字节 [at, len)。 at 必须位于 UTF-8 代码点的边界上。

请注意，self 的容量不会改变。

Panics

如果 at 不在 UTF-8 代码点边界上，或者它超出字符串的最后一个代码点，就会出现 panics。

Examples

let mut hello = String::from("Hello, World!");
let world = hello.split_off(7);
assert_eq!(hello, "Hello, ");
assert_eq!(world, "World!");

pub fn clear(&mut self)

截断此 String，删除所有内容。

虽然这意味着 String 的长度为零，但它并未触及其容量。

Examples

基本用法：

let mut s = String::from("foo");

s.clear();

assert!(s.is_empty());
assert_eq!(0, s.len());
assert_eq!(3, s.capacity());

pub fn drain<R>(&mut self, range: R) -> Drain<'_> where R: RangeBounds<usize>,

从字符串中批量删除指定范围，并以迭代器的形式返回所有删除的字符。

返回的迭代器在字符串上保留一个可变借用以优化其实现。

Panics

如果起始点或结束点不在 char 边界上，或超出边界，就会出现 panic。

Leaking

如果返回的迭代器离开作用域而没有被丢弃 (例如，由于 core::mem::forget)，则字符串可能仍包含任何耗尽字符的副本，或者可能任意丢失字符，包括范围外的字符。

Examples

基本用法：

let mut s = String::from("α is alpha, β is beta");
let beta_offset = s.find('β').unwrap_or(s.len());

// 删除范围直到字符串中的 β
let t: String = s.drain(..beta_offset).collect();
assert_eq!(t, "α is alpha, ");
assert_eq!(s, "β is beta");

// 全范围清除字符串，就像 `clear()` 一样
s.drain(..);
assert_eq!(s, "");

pub fn replace_range<R>(&mut self, range: R, replace_with: &str)where R: RangeBounds<usize>,

删除字符串中的指定范围，并将其替换为给定的字符串。 给定的字符串不必与范围相同。

Panics

如果起始点或结束点不在 char 边界上，或超出边界，就会出现 panic。

Examples

基本用法：

let mut s = String::from("α is alpha, β is beta");
let beta_offset = s.find('β').unwrap_or(s.len());

// 替换范围直到字符串中的 β
s.replace_range(..beta_offset, "Α is capital alpha; ");
assert_eq!(s, "Α is capital alpha; β is beta");

pub fn into_boxed_str(self) -> Box<str, Global>

将此 String 转换为 Box<str>。

这将丢弃任何多余的容量。

Examples

基本用法：

let s = String::from("hello");

let b = s.into_boxed_str();

pub fn leak<'a>(self) -> &'a mut str

🔬This is a nightly-only experimental API. (string_leak #102929)

消耗并泄漏 String，将可变引用返回到内容 &'a mut str。

这主要适用于在程序剩余生命周期中存在的数据。 丢弃返回的引用将导致内存泄漏。

它不会重新分配或收缩 String，因此泄漏的分配可能包括不属于返回片的未使用容量。

Examples

简单用法：

#![feature(string_leak)]

let x = String::from("bucket");
let static_ref: &'static mut str = x.leak();
assert_eq!(static_ref, "bucket");

Methods from Deref<Target = str>

pub fn len(&self) -> usize

返回 self 的长度。

该长度以字节为单位，而不是 char 或字素。 换句话说，它可能不是人类认为的字符串长度。

Examples

基本用法：

let len = "foo".len();
assert_eq!(3, len);

assert_eq!("ƒoo".len(), 4); // fancy f!
assert_eq!("ƒoo".chars().count(), 3);

pub fn is_empty(&self) -> bool

如果 self 的长度为零字节，则返回 true。

Examples

基本用法：

let s = "";
assert!(s.is_empty());

let s = "not empty";
assert!(!s.is_empty());

pub fn is_char_boundary(&self, index: usize) -> bool

检查第 index 个字节是 UTF-8 代码点序列中的第一个字节还是字符串的末尾。

字符串的开头和结尾 (当 index == self.len()) 被视为边界时。

如果 index 大于 self.len()，则返回 false。

Examples

let s = "Löwe 老虎 Léopard";
assert!(s.is_char_boundary(0));
// start of `老`
assert!(s.is_char_boundary(6));
assert!(s.is_char_boundary(s.len()));

// `ö` 的第二个字节
assert!(!s.is_char_boundary(2));

// third byte of `老`
assert!(!s.is_char_boundary(8));

pub fn floor_char_boundary(&self, index: usize) -> usize

🔬This is a nightly-only experimental API. (round_char_boundary #93743)

查找不超过 index 的最接近的 x，其中 is_char_boundary(x) 是 true。

此方法可以帮助您截断字符串，使其仍然是有效的 UTF-8，但不超过给定的字节数。 请注意，这纯粹是在字符级别完成的，并且仍然可以在视觉上分割字素，即使底层字符没有被分割。

例如，表情符号 🧑‍🔬 (科学家) 可以被拆分，以便字符串仅包含 🧑 (人)。

Examples

#![feature(round_char_boundary)]
let s = "❤️🧡💛💚💙💜";
assert_eq!(s.len(), 26);
assert!(!s.is_char_boundary(13));

let closest = s.floor_char_boundary(13);
assert_eq!(closest, 10);
assert_eq!(&s[..closest], "❤️🧡");

pub fn ceil_char_boundary(&self, index: usize) -> usize

🔬This is a nightly-only experimental API. (round_char_boundary #93743)

查找不低于 index 的最接近的 x，其中 is_char_boundary(x) 是 true。

这种方法是对 floor_char_boundary 的自然补充。 有关更多详细信息，请参见该方法。

Panics

如果 index > self.len()，就会出现 panic。

Examples

#![feature(round_char_boundary)]
let s = "❤️🧡💛💚💙💜";
assert_eq!(s.len(), 26);
assert!(!s.is_char_boundary(13));

let closest = s.ceil_char_boundary(13);
assert_eq!(closest, 14);
assert_eq!(&s[..closest], "❤️🧡💛");

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

将字符串切片转换为字节切片。 要将字节切片切回为字符串切片，请使用 from_utf8 函数。

Examples

基本用法：

let bytes = "bors".as_bytes();
assert_eq!(b"bors", bytes);

pub unsafe fn as_bytes_mut(&mut self) -> &mut [u8]

将可变字符串切片转换为可变字节切片。

Safety

调用者必须确保在借用结束和使用底层 str 之前，切片的内容是有效的 UTF-8。

使用内容无效的 str UTF-8 是未定义的行为。

Examples

基本用法：

let mut s = String::from("Hello");
let bytes = unsafe { s.as_bytes_mut() };

assert_eq!(b"Hello", bytes);

Mutability:

let mut s = String::from("🗻∈🌏");

unsafe {
    let bytes = s.as_bytes_mut();

    bytes[0] = 0xF0;
    bytes[1] = 0x9F;
    bytes[2] = 0x8D;
    bytes[3] = 0x94;
}

assert_eq!("🍔∈🌏", s);

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

将字符串切片转换为裸指针。

由于字符串切片是字节的切片，所以裸指针指向 u8。 该指针将指向字符串切片的第一个字节。

调用者必须确保返回的指针永远不会被写入。 如果需要更改字符串切片的内容，请使用 as_mut_ptr。

Examples

基本用法：

let s = "Hello";
let ptr = s.as_ptr();

pub fn as_mut_ptr(&mut self) -> *mut u8

将可变字符串切片转换为裸指针。

由于字符串切片是字节的切片，所以裸指针指向 u8。 该指针将指向字符串切片的第一个字节。

您有责任确保仅以有效的 UTF-8 方式修改字符串切片。

pub fn get<I>(&self, i: I) -> Option<&<I as SliceIndex<str>>::Output>where I: SliceIndex<str>,

返回 str 的子切片。

这是索引 str 的非紧急选择。 每当等效的索引操作将为 panic 时，将返回 None。

Examples

let v = String::from("🗻∈🌏");

assert_eq!(Some("🗻"), v.get(0..4));

// 索引不在 UTF-8 序列边界上
assert!(v.get(1..).is_none());
assert!(v.get(..8).is_none());

// 越界
assert!(v.get(..42).is_none());

pub fn get_mut<I>( &mut self, i: I ) -> Option<&mut <I as SliceIndex<str>>::Output>where I: SliceIndex<str>,

返回 str 的可变子切片。

这是索引 str 的非紧急选择。 每当等效的索引操作将为 panic 时，将返回 None。

Examples

let mut v = String::from("hello");
// 正确的长度
assert!(v.get_mut(0..5).is_some());
// 越界
assert!(v.get_mut(..42).is_none());
assert_eq!(Some("he"), v.get_mut(0..2).map(|v| &*v));

assert_eq!("hello", v);
{
    let s = v.get_mut(0..2);
    let s = s.map(|s| {
        s.make_ascii_uppercase();
        &*s
    });
    assert_eq!(Some("HE"), s);
}
assert_eq!("HEllo", v);

pub unsafe fn get_unchecked<I>(&self, i: I) -> &<I as SliceIndex<str>>::Outputwhere I: SliceIndex<str>,

返回未经检查的 str 子切片。

这是索引 str 的未经检查的替代方法。

Safety

此函数的调用者有责任满足以下先决条件：

• 起始索引不得超过结束索引；
• 索引必须在原始切片的范围内；
• 索引必须位于 UTF-8 序列边界上。

否则，返回的字符串切片可能会引用无效的内存或违反 str 类型传达的不变量。

Examples

let v = "🗻∈🌏";
unsafe {
    assert_eq!("🗻", v.get_unchecked(0..4));
    assert_eq!("∈", v.get_unchecked(4..7));
    assert_eq!("🌏", v.get_unchecked(7..11));
}

pub unsafe fn get_unchecked_mut<I>( &mut self, i: I ) -> &mut <I as SliceIndex<str>>::Outputwhere I: SliceIndex<str>,

返回 str 的可变，未经检查的子切片。

这是索引 str 的未经检查的替代方法。

Safety

此函数的调用者有责任满足以下先决条件：

• 起始索引不得超过结束索引；
• 索引必须在原始切片的范围内；
• 索引必须位于 UTF-8 序列边界上。

否则，返回的字符串切片可能会引用无效的内存或违反 str 类型传达的不变量。

Examples

let mut v = String::from("🗻∈🌏");
unsafe {
    assert_eq!("🗻", v.get_unchecked_mut(0..4));
    assert_eq!("∈", v.get_unchecked_mut(4..7));
    assert_eq!("🌏", v.get_unchecked_mut(7..11));
}

pub unsafe fn slice_unchecked(&self, begin: usize, end: usize) -> &str

👎Deprecated since 1.29.0: use get_unchecked(begin..end) instead

从另一个字符串切片中创建一个字符串切片，从而绕过安全检查。

通常不建议这样做，请谨慎使用！ 有关安全的替代方法，请参见 str 和 Index。

此新切片从 begin 到 end，包括 begin 但不包括 end。

要获取可变字符串切片，请参见 slice_mut_unchecked 方法。

Safety

此函数的调用者有责任满足三个先决条件：

• begin 不得超过 end。
• begin 和 end 必须是字符串切片内的字节位置。
• begin 和 end 必须位于 UTF-8 序列边界上。

Examples

基本用法：

let s = "Löwe 老虎 Léopard";

unsafe {
    assert_eq!("Löwe 老虎 Léopard", s.slice_unchecked(0, 21));
}

let s = "Hello, world!";

unsafe {
    assert_eq!("world", s.slice_unchecked(7, 12));
}

pub unsafe fn slice_mut_unchecked( &mut self, begin: usize, end: usize ) -> &mut str

👎Deprecated since 1.29.0: use get_unchecked_mut(begin..end) instead

从另一个字符串切片中创建一个字符串切片，从而绕过安全检查。 通常不建议这样做，请谨慎使用！ 有关安全的替代方案，请参见 str 和 IndexMut。

此新切片从 begin 到 end，包括 begin 但不包括 end。

要获取不可变的字符串切片，请参见 slice_unchecked 方法。

Safety

此函数的调用者有责任满足三个先决条件：

• begin 不得超过 end。
• begin 和 end 必须是字符串切片内的字节位置。
• begin 和 end 必须位于 UTF-8 序列边界上。

pub fn split_at(&self, mid: usize) -> (&str, &str)

在索引处将一个字符串切片分成两个。

参数 mid 应该是字符串开头的字节偏移量。 它也必须在 UTF-8 代码点的边界上。

返回的两个切片从字符串切片的开头到 mid，从 mid 到字符串切片的结尾。

要获取可变字符串切片，请参见 split_at_mut 方法。

Panics

如果 mid 不在 UTF-8 代码点边界上，或者它超过了字符串切片的最后一个代码点的末尾，就会出现 panics。

Examples

基本用法：

let s = "Per Martin-Löf";

let (first, last) = s.split_at(3);

assert_eq!("Per", first);
assert_eq!(" Martin-Löf", last);

pub fn split_at_mut(&mut self, mid: usize) -> (&mut str, &mut str)

在索引处将一个可变字符串切片切成两部分。

参数 mid 应该是字符串开头的字节偏移量。 它也必须在 UTF-8 代码点的边界上。

返回的两个切片从字符串切片的开头到 mid，从 mid 到字符串切片的结尾。

要获取不可变的字符串切片，请参见 split_at 方法。

Panics

如果 mid 不在 UTF-8 代码点边界上，或者它超过了字符串切片的最后一个代码点的末尾，就会出现 panics。

Examples

基本用法：

let mut s = "Per Martin-Löf".to_string();
{
    let (first, last) = s.split_at_mut(3);
    first.make_ascii_uppercase();
    assert_eq!("PER", first);
    assert_eq!(" Martin-Löf", last);
}
assert_eq!("PER Martin-Löf", s);

pub fn chars(&self) -> Chars<'_>

返回字符串切片的 char 上的迭代器。

由于字符串切片由有效的 UTF-8 组成，因此我们可以通过 char 遍历字符串切片。 此方法返回这样的迭代器。

请务必记住，char 表示 Unicode 标量值，可能与您对 ‘character’ 的概念不符。

实际需要的是在字形簇上进行迭代。 Rust 的标准库未提供此功能，请检查 crates.io。

Examples

基本用法：

let word = "goodbye";

let count = word.chars().count();
assert_eq!(7, count);

let mut chars = word.chars();

assert_eq!(Some('g'), chars.next());
assert_eq!(Some('o'), chars.next());
assert_eq!(Some('o'), chars.next());
assert_eq!(Some('d'), chars.next());
assert_eq!(Some('b'), chars.next());
assert_eq!(Some('y'), chars.next());
assert_eq!(Some('e'), chars.next());

assert_eq!(None, chars.next());

请记住，char 可能与您对字符的直觉不符：

let y = "y̆";

let mut chars = y.chars();

assert_eq!(Some('y'), chars.next()); // 不是 'y̆'
assert_eq!(Some('\u{0306}'), chars.next());

assert_eq!(None, chars.next());

pub fn char_indices(&self) -> CharIndices<'_>

返回字符串切片的 char 及其位置上的迭代器。

由于字符串切片由有效的 UTF-8 组成，因此我们可以通过 char 遍历字符串切片。 这个方法返回这两个 char 以及它们的字节位置的迭代器。

迭代器产生元组。位置是第一，char 是第二。

Examples

基本用法：

let word = "goodbye";

let count = word.char_indices().count();
assert_eq!(7, count);

let mut char_indices = word.char_indices();

assert_eq!(Some((0, 'g')), char_indices.next());
assert_eq!(Some((1, 'o')), char_indices.next());
assert_eq!(Some((2, 'o')), char_indices.next());
assert_eq!(Some((3, 'd')), char_indices.next());
assert_eq!(Some((4, 'b')), char_indices.next());
assert_eq!(Some((5, 'y')), char_indices.next());
assert_eq!(Some((6, 'e')), char_indices.next());

assert_eq!(None, char_indices.next());

请记住，char 可能与您对字符的直觉不符：

let yes = "y̆es";

let mut char_indices = yes.char_indices();

assert_eq!(Some((0, 'y')), char_indices.next()); // 不是 (0，'y̆')
assert_eq!(Some((1, '\u{0306}')), char_indices.next());

// 注意这里的 3 - 最后一个字符占用了两个字节
assert_eq!(Some((3, 'e')), char_indices.next());
assert_eq!(Some((4, 's')), char_indices.next());

assert_eq!(None, char_indices.next());

pub fn bytes(&self) -> Bytes<'_>

在字符串切片的字节上进行迭代的迭代器。

由于字符串切片由字节序列组成，因此我们可以逐字节遍历字符串切片。 此方法返回这样的迭代器。

Examples

基本用法：

let mut bytes = "bors".bytes();

assert_eq!(Some(b'b'), bytes.next());
assert_eq!(Some(b'o'), bytes.next());
assert_eq!(Some(b'r'), bytes.next());
assert_eq!(Some(b's'), bytes.next());

assert_eq!(None, bytes.next());

pub fn split_whitespace(&self) -> SplitWhitespace<'_>

用空格分割字符串切片。

返回的迭代器将返回作为原始字符串切片的子切片的字符串切片，并以任意数量的空格分隔。

‘Whitespace’ 是根据 Unicode 派生核心属性 White_Space 的条款定义的。 如果只想在 ASCII 空格上分割，请使用 split_ascii_whitespace。

Examples

基本用法：

let mut iter = "A few words".split_whitespace();

assert_eq!(Some("A"), iter.next());
assert_eq!(Some("few"), iter.next());
assert_eq!(Some("words"), iter.next());

assert_eq!(None, iter.next());

考虑所有类型的空白：

let mut iter = " Mary   had\ta\u{2009}little  \n\t lamb".split_whitespace();
assert_eq!(Some("Mary"), iter.next());
assert_eq!(Some("had"), iter.next());
assert_eq!(Some("a"), iter.next());
assert_eq!(Some("little"), iter.next());
assert_eq!(Some("lamb"), iter.next());

assert_eq!(None, iter.next());

如果字符串为空或全为空白，则迭代器不产生字符串切片:

assert_eq!("".split_whitespace().next(), None);
assert_eq!("   ".split_whitespace().next(), None);

pub fn split_ascii_whitespace(&self) -> SplitAsciiWhitespace<'_>

用 ASCII 空格分割字符串切片。

返回的迭代器将返回作为原始字符串切片的子切片的字符串切片，并以任意数量的 ASCII 空格分隔。

要改为按 Unicode Whitespace 进行拆分，请使用 split_whitespace。

Examples

基本用法：

let mut iter = "A few words".split_ascii_whitespace();

assert_eq!(Some("A"), iter.next());
assert_eq!(Some("few"), iter.next());
assert_eq!(Some("words"), iter.next());

assert_eq!(None, iter.next());

考虑所有类型的 ASCII 空白：

let mut iter = " Mary   had\ta little  \n\t lamb".split_ascii_whitespace();
assert_eq!(Some("Mary"), iter.next());
assert_eq!(Some("had"), iter.next());
assert_eq!(Some("a"), iter.next());
assert_eq!(Some("little"), iter.next());
assert_eq!(Some("lamb"), iter.next());

assert_eq!(None, iter.next());

如果字符串为空或全部为 ASCII 空格，则迭代器不产生字符串切片:

assert_eq!("".split_ascii_whitespace().next(), None);
assert_eq!("   ".split_ascii_whitespace().next(), None);

pub fn lines(&self) -> Lines<'_>

在字符串的各行上进行迭代的迭代器，作为字符串切片。

行在换行符 (\n) 或回车符后跟换行符 (\r\n) 的行尾处拆分。

迭代器返回的行中不包含行终止符。

最后一行的结尾是可选的。 以最后一行结尾的字符串将返回与没有其他最后一行结尾的相同字符串相同的行。

Examples

基本用法：

let text = "foo\r\nbar\n\nbaz\n";
let mut lines = text.lines();

assert_eq!(Some("foo"), lines.next());
assert_eq!(Some("bar"), lines.next());
assert_eq!(Some(""), lines.next());
assert_eq!(Some("baz"), lines.next());

assert_eq!(None, lines.next());

不需要最后一行：

let text = "foo\nbar\n\r\nbaz";
let mut lines = text.lines();

assert_eq!(Some("foo"), lines.next());
assert_eq!(Some("bar"), lines.next());
assert_eq!(Some(""), lines.next());
assert_eq!(Some("baz"), lines.next());

assert_eq!(None, lines.next());

pub fn lines_any(&self) -> LinesAny<'_>

👎Deprecated since 1.4.0: use lines() instead now

字符串行上的迭代器。

pub fn encode_utf16(&self) -> EncodeUtf16<'_>

在编码为 UTF-16 的字符串上返回 u16 的迭代器。

Examples

基本用法：

let text = "Zażółć gęślą jaźń";

let utf8_len = text.len();
let utf16_len = text.encode_utf16().count();

assert!(utf16_len <= utf8_len);

pub fn contains<'a, P>(&'a self, pat: P) -> boolwhere P: Pattern<'a>,

如果给定的模式与该字符串切片的子切片匹配，则返回 true。

如果不是，则返回 false。

模式 可以是 &str，char，char 的切片，也可以是确定字符是否匹配的函数或闭包。

Examples

基本用法：

let bananas = "bananas";

assert!(bananas.contains("nana"));
assert!(!bananas.contains("apples"));

pub fn starts_with<'a, P>(&'a self, pat: P) -> boolwhere P: Pattern<'a>,

如果给定的模式与此字符串切片的前缀匹配，则返回 true。

如果不是，则返回 false。

模式 可以是 &str，char，char 的切片，也可以是确定字符是否匹配的函数或闭包。

Examples

基本用法：

let bananas = "bananas";

assert!(bananas.starts_with("bana"));
assert!(!bananas.starts_with("nana"));

pub fn ends_with<'a, P>(&'a self, pat: P) -> boolwhere P: Pattern<'a>, <P as Pattern<'a>>::Searcher: ReverseSearcher<'a>,

如果给定的模式与该字符串切片的后缀匹配，则返回 true。

如果不是，则返回 false。

模式 可以是 &str，char，char 的切片，也可以是确定字符是否匹配的函数或闭包。

Examples

基本用法：

let bananas = "bananas";

assert!(bananas.ends_with("anas"));
assert!(!bananas.ends_with("nana"));

pub fn find<'a, P>(&'a self, pat: P) -> Option<usize>where P: Pattern<'a>,

返回此字符串切片中与模式匹配的第一个字符的字节索引。

如果模式不匹配，则返回 None。

模式 可以是 &str，char，char 的切片，也可以是确定字符是否匹配的函数或闭包。

Examples

简单模式：

let s = "Löwe 老虎 Léopard Gepardi";

assert_eq!(s.find('L'), Some(0));
assert_eq!(s.find('é'), Some(14));
assert_eq!(s.find("pard"), Some(17));

使用无点样式和闭包的更复杂的模式：

let s = "Löwe 老虎 Léopard";

assert_eq!(s.find(char::is_whitespace), Some(5));
assert_eq!(s.find(char::is_lowercase), Some(1));
assert_eq!(s.find(|c: char| c.is_whitespace() || c.is_lowercase()), Some(1));
assert_eq!(s.find(|c: char| (c < 'o') && (c > 'a')), Some(4));

找不到模式：

let s = "Löwe 老虎 Léopard";
let x: &[_] = &['1', '2'];

assert_eq!(s.find(x), None);

pub fn rfind<'a, P>(&'a self, pat: P) -> Option<usize>where P: Pattern<'a>, <P as Pattern<'a>>::Searcher: ReverseSearcher<'a>,

返回此字符串切片中模式的最后一个匹配项的第一个字符的字节索引。

如果模式不匹配，则返回 None。

模式 可以是 &str，char，char 的切片，也可以是确定字符是否匹配的函数或闭包。

Examples

简单模式：

let s = "Löwe 老虎 Léopard Gepardi";

assert_eq!(s.rfind('L'), Some(13));
assert_eq!(s.rfind('é'), Some(14));
assert_eq!(s.rfind("pard"), Some(24));

闭包的更复杂模式：

let s = "Löwe 老虎 Léopard";

assert_eq!(s.rfind(char::is_whitespace), Some(12));
assert_eq!(s.rfind(char::is_lowercase), Some(20));

找不到模式：

let s = "Löwe 老虎 Léopard";
let x: &[_] = &['1', '2'];

assert_eq!(s.rfind(x), None);

pub fn split<'a, P>(&'a self, pat: P) -> Split<'a, P> where P: Pattern<'a>,

在此字符串切片的子字符串上进行迭代的迭代器，该子字符串由模式匹配的字符分隔。

模式 可以是 &str，char，char 的切片，也可以是确定字符是否匹配的函数或闭包。

迭代器行为

如果模式允许反向搜索且 forward/reverse 搜索产生相同的元素，则返回的迭代器将为 DoubleEndedIterator。 例如，对于 char，这是正确的，但对于 &str，则不是。

如果模式允许反向搜索，但其结果可能与正向搜索不同，则可以使用 rsplit 方法。

Examples

简单模式：

let v: Vec<&str> = "Mary had a little lamb".split(' ').collect();
assert_eq!(v, ["Mary", "had", "a", "little", "lamb"]);

let v: Vec<&str> = "".split('X').collect();
assert_eq!(v, [""]);

let v: Vec<&str> = "lionXXtigerXleopard".split('X').collect();
assert_eq!(v, ["lion", "", "tiger", "leopard"]);

let v: Vec<&str> = "lion::tiger::leopard".split("::").collect();
assert_eq!(v, ["lion", "tiger", "leopard"]);

let v: Vec<&str> = "abc1def2ghi".split(char::is_numeric).collect();
assert_eq!(v, ["abc", "def", "ghi"]);

let v: Vec<&str> = "lionXtigerXleopard".split(char::is_uppercase).collect();
assert_eq!(v, ["lion", "tiger", "leopard"]);

如果模式是一片字符，请在每次出现任何字符时进行分割：

let v: Vec<&str> = "2020-11-03 23:59".split(&['-', ' ', ':', '@'][..]).collect();
assert_eq!(v, ["2020", "11", "03", "23", "59"]);

使用闭包的更复杂的模式：

let v: Vec<&str> = "abc1defXghi".split(|c| c == '1' || c == 'X').collect();
assert_eq!(v, ["abc", "def", "ghi"]);

如果一个字符串包含多个连续的分隔符，您将在输出中得到空字符串：

let x = "||||a||b|c".to_string();
let d: Vec<_> = x.split('|').collect();

assert_eq!(d, &["", "", "", "", "a", "", "b", "c"]);

连续的分隔符由空字符串分隔。

let x = "(///)".to_string();
let d: Vec<_> = x.split('/').collect();

assert_eq!(d, &["(", "", "", ")"]);

字符串开头或结尾的分隔符与空字符串相邻。

let d: Vec<_> = "010".split("0").collect();
assert_eq!(d, &["", "1", ""]);

当空字符串用作分隔符时，它将字符串中的每个字符以及字符串的开头和结尾分隔开。

let f: Vec<_> = "rust".split("").collect();
assert_eq!(f, &["", "r", "u", "s", "t", ""]);

当使用空格作为分隔符时，连续的分隔符可能会导致令人惊讶的行为。这段代码是正确的：

let x = "    a  b c".to_string();
let d: Vec<_> = x.split(' ').collect();

assert_eq!(d, &["", "", "", "", "a", "", "b", "c"]);

它确实不会给您：

assert_eq!(d, &["a", "b", "c"]);

为此行为使用 split_whitespace。

pub fn split_inclusive<'a, P>(&'a self, pat: P) -> SplitInclusive<'a, P> where P: Pattern<'a>,

在此字符串切片的子字符串上进行迭代的迭代器，该子字符串由模式匹配的字符分隔。 与 split 产生的迭代器的不同之处在于 split_inclusive 将匹配的部分保留为子字符串的终止符。

模式 可以是 &str，char，char 的切片，也可以是确定字符是否匹配的函数或闭包。

Examples

let v: Vec<&str> = "Mary had a little lamb\nlittle lamb\nlittle lamb."
    .split_inclusive('\n').collect();
assert_eq!(v, ["Mary had a little lamb\n", "little lamb\n", "little lamb."]);

如果字符串的最后一个元素匹配，则该元素将被视为前一个子字符串的终止符。 该子字符串将是迭代器返回的最后一个项。

let v: Vec<&str> = "Mary had a little lamb\nlittle lamb\nlittle lamb.\n"
    .split_inclusive('\n').collect();
assert_eq!(v, ["Mary had a little lamb\n", "little lamb\n", "little lamb.\n"]);

pub fn rsplit<'a, P>(&'a self, pat: P) -> RSplit<'a, P> where P: Pattern<'a>, <P as Pattern<'a>>::Searcher: ReverseSearcher<'a>,

给定字符串切片的子字符串上的迭代器，该迭代器由与模式匹配的字符分隔，并以相反的顺序产生。

模式 可以是 &str，char，char 的切片，也可以是确定字符是否匹配的函数或闭包。

迭代器行为

返回的迭代器要求模式支持反向搜索，如果 forward/reverse 搜索产生相同的元素，它将是 DoubleEndedIterator。

为了从正面进行迭代，可以使用 split 方法。

Examples

简单模式：

let v: Vec<&str> = "Mary had a little lamb".rsplit(' ').collect();
assert_eq!(v, ["lamb", "little", "a", "had", "Mary"]);

let v: Vec<&str> = "".rsplit('X').collect();
assert_eq!(v, [""]);

let v: Vec<&str> = "lionXXtigerXleopard".rsplit('X').collect();
assert_eq!(v, ["leopard", "tiger", "", "lion"]);

let v: Vec<&str> = "lion::tiger::leopard".rsplit("::").collect();
assert_eq!(v, ["leopard", "tiger", "lion"]);

使用闭包的更复杂的模式：

let v: Vec<&str> = "abc1defXghi".rsplit(|c| c == '1' || c == 'X').collect();
assert_eq!(v, ["ghi", "def", "abc"]);

pub fn split_terminator<'a, P>(&'a self, pat: P) -> SplitTerminator<'a, P> where P: Pattern<'a>,

给定字符串切片的子字符串上的迭代器，该子字符串由模式匹配的字符分隔。

模式 可以是 &str，char，char 的切片，也可以是确定字符是否匹配的函数或闭包。

等效于 split，不同之处在于尾随的子字符串为空时将被跳过。

此方法可用于 terminated 的字符串数据，而不是用于模式的 separated 的字符串数据。

迭代器行为

如果模式允许反向搜索且 forward/reverse 搜索产生相同的元素，则返回的迭代器将为 DoubleEndedIterator。 例如，对于 char，这是正确的，但对于 &str，则不是。

如果模式允许反向搜索，但其结果可能与正向搜索不同，则可以使用 rsplit_terminator 方法。

Examples

基本用法：

let v: Vec<&str> = "A.B.".split_terminator('.').collect();
assert_eq!(v, ["A", "B"]);

let v: Vec<&str> = "A..B..".split_terminator(".").collect();
assert_eq!(v, ["A", "", "B", ""]);

let v: Vec<&str> = "A.B:C.D".split_terminator(&['.', ':'][..]).collect();
assert_eq!(v, ["A", "B", "C", "D"]);

pub fn rsplit_terminator<'a, P>(&'a self, pat: P) -> RSplitTerminator<'a, P> where P: Pattern<'a>, <P as Pattern<'a>>::Searcher: ReverseSearcher<'a>,

self 子字符串上的迭代器，该迭代器由与模式匹配的字符分隔，并以相反的顺序产生。

模式 可以是 &str，char，char 的切片，也可以是确定字符是否匹配的函数或闭包。

等效于 split，不同之处在于尾随的子字符串为空时将被跳过。

此方法可用于 terminated 的字符串数据，而不是用于模式的 separated 的字符串数据。

迭代器行为

返回的迭代器要求模式支持反向搜索，如果 forward/reverse 搜索产生相同的元素，则它将是双头模式。

为了从正面进行迭代，可以使用 split_terminator 方法。

Examples

let v: Vec<&str> = "A.B.".rsplit_terminator('.').collect();
assert_eq!(v, ["B", "A"]);

let v: Vec<&str> = "A..B..".rsplit_terminator(".").collect();
assert_eq!(v, ["", "B", "", "A"]);

let v: Vec<&str> = "A.B:C.D".rsplit_terminator(&['.', ':'][..]).collect();
assert_eq!(v, ["D", "C", "B", "A"]);

pub fn splitn<'a, P>(&'a self, n: usize, pat: P) -> SplitN<'a, P> where P: Pattern<'a>,

给定字符串切片的子字符串上的迭代器 (由模式分隔)，仅限于返回最多 n 项。

如果返回 n 子字符串，则最后一个子字符串 (第 n 个子字符串) 将包含字符串的其余部分。

模式 可以是 &str，char，char 的切片，也可以是确定字符是否匹配的函数或闭包。

迭代器行为

返回的迭代器不会是双头的，因为支持效率不高。

如果模式允许反向搜索，则可以使用 rsplitn 方法。

Examples

简单模式：

let v: Vec<&str> = "Mary had a little lambda".splitn(3, ' ').collect();
assert_eq!(v, ["Mary", "had", "a little lambda"]);

let v: Vec<&str> = "lionXXtigerXleopard".splitn(3, "X").collect();
assert_eq!(v, ["lion", "", "tigerXleopard"]);

let v: Vec<&str> = "abcXdef".splitn(1, 'X').collect();
assert_eq!(v, ["abcXdef"]);

let v: Vec<&str> = "".splitn(1, 'X').collect();
assert_eq!(v, [""]);

使用闭包的更复杂的模式：

let v: Vec<&str> = "abc1defXghi".splitn(2, |c| c == '1' || c == 'X').collect();
assert_eq!(v, ["abc", "defXghi"]);

pub fn rsplitn<'a, P>(&'a self, n: usize, pat: P) -> RSplitN<'a, P> where P: Pattern<'a>, <P as Pattern<'a>>::Searcher: ReverseSearcher<'a>,

从字符串的末尾开始，在此字符串切片的子字符串上进行迭代的迭代器，由模式分隔，限制为最多返回 n 项。

如果返回 n 子字符串，则最后一个子字符串 (第 n 个子字符串) 将包含字符串的其余部分。

模式 可以是 &str，char，char 的切片，也可以是确定字符是否匹配的函数或闭包。

迭代器行为

返回的迭代器不会是双头的，因为支持效率不高。

要从正面拆分，可以使用 splitn 方法。

Examples

简单模式：

let v: Vec<&str> = "Mary had a little lamb".rsplitn(3, ' ').collect();
assert_eq!(v, ["lamb", "little", "Mary had a"]);

let v: Vec<&str> = "lionXXtigerXleopard".rsplitn(3, 'X').collect();
assert_eq!(v, ["leopard", "tiger", "lionX"]);

let v: Vec<&str> = "lion::tiger::leopard".rsplitn(2, "::").collect();
assert_eq!(v, ["leopard", "lion::tiger"]);

使用闭包的更复杂的模式：

let v: Vec<&str> = "abc1defXghi".rsplitn(2, |c| c == '1' || c == 'X').collect();
assert_eq!(v, ["ghi", "abc1def"]);

pub fn split_once<'a, P>(&'a self, delimiter: P) -> Option<(&'a str, &'a str)>where P: Pattern<'a>,

在第一次出现指定分隔符时拆分字符串，并在分隔符之前返回前缀，在分隔符之后返回后缀。

Examples

assert_eq!("cfg".split_once('='), None);
assert_eq!("cfg=".split_once('='), Some(("cfg", "")));
assert_eq!("cfg=foo".split_once('='), Some(("cfg", "foo")));
assert_eq!("cfg=foo=bar".split_once('='), Some(("cfg", "foo=bar")));

pub fn rsplit_once<'a, P>(&'a self, delimiter: P) -> Option<(&'a str, &'a str)>where P: Pattern<'a>, <P as Pattern<'a>>::Searcher: ReverseSearcher<'a>,

在最后一次出现指定分隔符时分割字符串，并在分隔符之前返回前缀，在分隔符之后返回后缀。

Examples

assert_eq!("cfg".rsplit_once('='), None);
assert_eq!("cfg=foo".rsplit_once('='), Some(("cfg", "foo")));
assert_eq!("cfg=foo=bar".rsplit_once('='), Some(("cfg=foo", "bar")));

pub fn matches<'a, P>(&'a self, pat: P) -> Matches<'a, P> where P: Pattern<'a>,

给定字符串切片中某个模式的不相交匹配的迭代器。

模式 可以是 &str，char，char 的切片，也可以是确定字符是否匹配的函数或闭包。

迭代器行为

如果模式允许反向搜索且 forward/reverse 搜索产生相同的元素，则返回的迭代器将为 DoubleEndedIterator。 例如，对于 char，这是正确的，但对于 &str，则不是。

如果模式允许反向搜索，但其结果可能与正向搜索不同，则可以使用 rmatches 方法。

Examples

基本用法：

let v: Vec<&str> = "abcXXXabcYYYabc".matches("abc").collect();
assert_eq!(v, ["abc", "abc", "abc"]);

let v: Vec<&str> = "1abc2abc3".matches(char::is_numeric).collect();
assert_eq!(v, ["1", "2", "3"]);

pub fn rmatches<'a, P>(&'a self, pat: P) -> RMatches<'a, P> where P: Pattern<'a>, <P as Pattern<'a>>::Searcher: ReverseSearcher<'a>,

在此字符串切片中某个模式的不相交匹配项上进行迭代的迭代器，其生成顺序相反。

模式 可以是 &str，char，char 的切片，也可以是确定字符是否匹配的函数或闭包。

迭代器行为

返回的迭代器要求模式支持反向搜索，如果 forward/reverse 搜索产生相同的元素，它将是 DoubleEndedIterator。

为了从正面进行迭代，可以使用 matches 方法。

Examples

基本用法：

let v: Vec<&str> = "abcXXXabcYYYabc".rmatches("abc").collect();
assert_eq!(v, ["abc", "abc", "abc"]);

let v: Vec<&str> = "1abc2abc3".rmatches(char::is_numeric).collect();
assert_eq!(v, ["3", "2", "1"]);

pub fn match_indices<'a, P>(&'a self, pat: P) -> MatchIndices<'a, P> where P: Pattern<'a>,

对该字符串切片中某个模式的不相交匹配以及该匹配开始处的索引的迭代器。

对于 self 中重叠的 pat 匹配项，仅返回与第一个匹配项对应的索引。

模式 可以是 &str，char，char 的切片，也可以是确定字符是否匹配的函数或闭包。

迭代器行为

如果模式允许反向搜索且 forward/reverse 搜索产生相同的元素，则返回的迭代器将为 DoubleEndedIterator。 例如，对于 char，这是正确的，但对于 &str，则不是。

如果模式允许反向搜索，但其结果可能与正向搜索不同，则可以使用 rmatch_indices 方法。

Examples

基本用法：

let v: Vec<_> = "abcXXXabcYYYabc".match_indices("abc").collect();
assert_eq!(v, [(0, "abc"), (6, "abc"), (12, "abc")]);

let v: Vec<_> = "1abcabc2".match_indices("abc").collect();
assert_eq!(v, [(1, "abc"), (4, "abc")]);

let v: Vec<_> = "ababa".match_indices("aba").collect();
assert_eq!(v, [(0, "aba")]); // 只有第一个 `aba`

pub fn rmatch_indices<'a, P>(&'a self, pat: P) -> RMatchIndices<'a, P> where P: Pattern<'a>, <P as Pattern<'a>>::Searcher: ReverseSearcher<'a>,

self 中某个模式的不相交匹配项上的迭代器，以与匹配项索引相反的顺序产生。

对于 self 中的 pat 重叠的匹配项，仅返回与最后一个匹配项对应的索引。

模式 可以是 &str，char，char 的切片，也可以是确定字符是否匹配的函数或闭包。

迭代器行为

返回的迭代器要求模式支持反向搜索，如果 forward/reverse 搜索产生相同的元素，它将是 DoubleEndedIterator。

为了从正面进行迭代，可以使用 match_indices 方法。

Examples

基本用法：

let v: Vec<_> = "abcXXXabcYYYabc".rmatch_indices("abc").collect();
assert_eq!(v, [(12, "abc"), (6, "abc"), (0, "abc")]);

let v: Vec<_> = "1abcabc2".rmatch_indices("abc").collect();
assert_eq!(v, [(4, "abc"), (1, "abc")]);

let v: Vec<_> = "ababa".rmatch_indices("aba").collect();
assert_eq!(v, [(2, "aba")]); // 只有最后的 `aba`

pub fn trim(&self) -> &str

返回除去前导和尾随空格的字符串切片。

‘Whitespace’ 是根据 Unicode 派生的核心属性 White_Space 的术语定义的，该属性包括换行符。

Examples

基本用法：

let s = "\n Hello\tworld\t\n";

assert_eq!("Hello\tworld", s.trim());

pub fn trim_start(&self) -> &str

返回除去前导空格的字符串切片。

‘Whitespace’ 是根据 Unicode 派生的核心属性 White_Space 的术语定义的，该属性包括换行符。

文字方向性

字符串是字节序列。 start 在此上下文中表示该字节字符串的第一个位置； 对于从左到右的语言 (例如英语或俄语)，这将是左侧; 对于从右到左的语言 (例如阿拉伯语或希伯来语)，这将是右侧。

Examples

基本用法：

let s = "\n Hello\tworld\t\n";
assert_eq!("Hello\tworld\t\n", s.trim_start());

Directionality:

let s = "  English  ";
assert!(Some('E') == s.trim_start().chars().next());

let s = "  עברית  ";
assert!(Some('ע') == s.trim_start().chars().next());

pub fn trim_end(&self) -> &str

返回除去尾随空格的字符串切片。

‘Whitespace’ 是根据 Unicode 派生的核心属性 White_Space 的术语定义的，该属性包括换行符。

文字方向性

字符串是字节序列。 end 在此上下文中表示该字节字符串的最后位置； 对于从左到右的语言 (例如英语或俄语)，这将在右侧; 对于从右到左的语言 (例如阿拉伯语或希伯来语)，将在左侧。

Examples

基本用法：

let s = "\n Hello\tworld\t\n";
assert_eq!("\n Hello\tworld", s.trim_end());

Directionality:

let s = "  English  ";
assert!(Some('h') == s.trim_end().chars().rev().next());

let s = "  עברית  ";
assert!(Some('ת') == s.trim_end().chars().rev().next());

pub fn trim_left(&self) -> &str

👎Deprecated since 1.33.0: superseded by trim_start

返回除去前导空格的字符串切片。

‘Whitespace’ 是根据 Unicode 派生核心属性 White_Space 的条款定义的。

文字方向性

字符串是字节序列。 ‘Left’ 在此上下文中表示该字节字符串的第一个位置； 对于像阿拉伯语或希伯来语这样从右到左而不是从左到右的语言，这将是右侧，而不是左侧。

Examples

基本用法：

let s = " Hello\tworld\t";

assert_eq!("Hello\tworld\t", s.trim_left());

Directionality:

let s = "  English";
assert!(Some('E') == s.trim_left().chars().next());

let s = "  עברית";
assert!(Some('ע') == s.trim_left().chars().next());

pub fn trim_right(&self) -> &str

👎Deprecated since 1.33.0: superseded by trim_end

返回除去尾随空格的字符串切片。

‘Whitespace’ 是根据 Unicode 派生核心属性 White_Space 的条款定义的。

文字方向性

字符串是字节序列。 ‘Right’ 在此上下文中表示该字节字符串的最后位置； 对于像阿拉伯语或希伯来语这样从右到左而不是从左到右的语言，这将是左侧，而不是右侧。

Examples

基本用法：

let s = " Hello\tworld\t";

assert_eq!(" Hello\tworld", s.trim_right());

Directionality:

let s = "English  ";
assert!(Some('h') == s.trim_right().chars().rev().next());

let s = "עברית  ";
assert!(Some('ת') == s.trim_right().chars().rev().next());

pub fn trim_matches<'a, P>(&'a self, pat: P) -> &'a strwhere P: Pattern<'a>, <P as Pattern<'a>>::Searcher: DoubleEndedSearcher<'a>,

返回具有与重复删除的模式匹配的所有前缀和后缀的字符串切片。

模式 可以是 char、char 的切片，也可以是确定字符是否匹配的函数或闭包。

Examples

简单模式：

assert_eq!("11foo1bar11".trim_matches('1'), "foo1bar");
assert_eq!("123foo1bar123".trim_matches(char::is_numeric), "foo1bar");

let x: &[_] = &['1', '2'];
assert_eq!("12foo1bar12".trim_matches(x), "foo1bar");

使用闭包的更复杂的模式：

assert_eq!("1foo1barXX".trim_matches(|c| c == '1' || c == 'X'), "foo1bar");

pub fn trim_start_matches<'a, P>(&'a self, pat: P) -> &'a strwhere P: Pattern<'a>,

返回字符串切片，该字符串切片的所有前缀都与重复删除的模式匹配。

模式 可以是 &str，char，char 的切片，也可以是确定字符是否匹配的函数或闭包。

文字方向性

字符串是字节序列。 start 在此上下文中表示该字节字符串的第一个位置； 对于从左到右的语言 (例如英语或俄语)，这将是左侧; 对于从右到左的语言 (例如阿拉伯语或希伯来语)，这将是右侧。

Examples

基本用法：

assert_eq!("11foo1bar11".trim_start_matches('1'), "foo1bar11");
assert_eq!("123foo1bar123".trim_start_matches(char::is_numeric), "foo1bar123");

let x: &[_] = &['1', '2'];
assert_eq!("12foo1bar12".trim_start_matches(x), "foo1bar12");

pub fn strip_prefix<'a, P>(&'a self, prefix: P) -> Option<&'a str>where P: Pattern<'a>,

返回删除了前缀的字符串切片。

如果字符串以模式 prefix 开头，则返回前缀在 Some 中的子字符串。 与 trim_start_matches 不同，此方法只删除一次前缀。

如果字符串不是以 prefix 开头，则返回 None。

模式 可以是 &str，char，char 的切片，也可以是确定字符是否匹配的函数或闭包。

Examples

assert_eq!("foo:bar".strip_prefix("foo:"), Some("bar"));
assert_eq!("foo:bar".strip_prefix("bar"), None);
assert_eq!("foofoo".strip_prefix("foo"), Some("foo"));

pub fn strip_suffix<'a, P>(&'a self, suffix: P) -> Option<&'a str>where P: Pattern<'a>, <P as Pattern<'a>>::Searcher: ReverseSearcher<'a>,

返回删除了后缀的字符串切片。

如果字符串以模式 suffix 结尾，则返回用 Some 包装的后缀之前的子字符串。 与 trim_end_matches 不同，此方法仅将后缀删除一次。

如果字符串不以 suffix 结尾，则返回 None。

模式 可以是 &str，char，char 的切片，也可以是确定字符是否匹配的函数或闭包。

Examples

assert_eq!("bar:foo".strip_suffix(":foo"), Some("bar"));
assert_eq!("bar:foo".strip_suffix("bar"), None);
assert_eq!("foofoo".strip_suffix("foo"), Some("foo"));

pub fn trim_end_matches<'a, P>(&'a self, pat: P) -> &'a strwhere P: Pattern<'a>, <P as Pattern<'a>>::Searcher: ReverseSearcher<'a>,

返回一个字符串切片，该字符串具有与重复删除的模式匹配的所有后缀。

模式 可以是 &str，char，char 的切片，也可以是确定字符是否匹配的函数或闭包。

文字方向性

字符串是字节序列。 end 在此上下文中表示该字节字符串的最后位置； 对于从左到右的语言 (例如英语或俄语)，这将在右侧; 对于从右到左的语言 (例如阿拉伯语或希伯来语)，将在左侧。

Examples

简单模式：

assert_eq!("11foo1bar11".trim_end_matches('1'), "11foo1bar");
assert_eq!("123foo1bar123".trim_end_matches(char::is_numeric), "123foo1bar");

let x: &[_] = &['1', '2'];
assert_eq!("12foo1bar12".trim_end_matches(x), "12foo1bar");

使用闭包的更复杂的模式：

assert_eq!("1fooX".trim_end_matches(|c| c == '1' || c == 'X'), "1foo");

pub fn trim_left_matches<'a, P>(&'a self, pat: P) -> &'a strwhere P: Pattern<'a>,

👎Deprecated since 1.33.0: superseded by trim_start_matches

返回字符串切片，该字符串切片的所有前缀都与重复删除的模式匹配。

模式 可以是 &str，char，char 的切片，也可以是确定字符是否匹配的函数或闭包。

文字方向性

字符串是字节序列。 ‘Left’ 在此上下文中表示该字节字符串的第一个位置； 对于像阿拉伯语或希伯来语这样从右到左而不是从左到右的语言，这将是右侧，而不是左侧。

Examples

基本用法：

assert_eq!("11foo1bar11".trim_left_matches('1'), "foo1bar11");
assert_eq!("123foo1bar123".trim_left_matches(char::is_numeric), "foo1bar123");

let x: &[_] = &['1', '2'];
assert_eq!("12foo1bar12".trim_left_matches(x), "foo1bar12");

pub fn trim_right_matches<'a, P>(&'a self, pat: P) -> &'a strwhere P: Pattern<'a>, <P as Pattern<'a>>::Searcher: ReverseSearcher<'a>,

👎Deprecated since 1.33.0: superseded by trim_end_matches

返回一个字符串切片，该字符串具有与重复删除的模式匹配的所有后缀。

模式 可以是 &str，char，char 的切片，也可以是确定字符是否匹配的函数或闭包。

文字方向性

字符串是字节序列。 ‘Right’ 在此上下文中表示该字节字符串的最后位置； 对于像阿拉伯语或希伯来语这样从右到左而不是从左到右的语言，这将是左侧，而不是右侧。

Examples

简单模式：

assert_eq!("11foo1bar11".trim_right_matches('1'), "11foo1bar");
assert_eq!("123foo1bar123".trim_right_matches(char::is_numeric), "123foo1bar");

let x: &[_] = &['1', '2'];
assert_eq!("12foo1bar12".trim_right_matches(x), "12foo1bar");

使用闭包的更复杂的模式：

assert_eq!("1fooX".trim_right_matches(|c| c == '1' || c == 'X'), "1foo");

pub fn parse<F>(&self) -> Result<F, <F as FromStr>::Err>where F: FromStr,

将此字符串切片解析为另一种类型。

由于 parse 非常通用，因此可能导致类型推断问题。 因此，parse 是少数几次您会看到被亲切地称为 ‘turbofish’: ::<> 的语法之一。

这可以帮助推理算法特别了解您要解析为哪种类型。

parse 可以解析为任何实现 FromStr trait 的类型。

Errors

如果无法将此字符串切片解析为所需的类型，则将返回 Err。

Examples

基本用法

let four: u32 = "4".parse().unwrap();

assert_eq!(4, four);

使用 ‘turbofish’ 而不是注解 four：

let four = "4".parse::<u32>();

assert_eq!(Ok(4), four);

无法解析：

let nope = "j".parse::<u32>();

assert!(nope.is_err());

pub fn is_ascii(&self) -> bool

检查此字符串中的所有字符是否都在 ASCII 范围内。

Examples

let ascii = "hello!\n";
let non_ascii = "Grüße, Jürgen ❤";

assert!(ascii.is_ascii());
assert!(!non_ascii.is_ascii());

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

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

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

pub fn eq_ignore_ascii_case(&self, other: &str) -> bool

检查两个字符串是否为 ASCII 不区分大小写的匹配项。

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

Examples

assert!("Ferris".eq_ignore_ascii_case("FERRIS"));
assert!("Ferrös".eq_ignore_ascii_case("FERRöS"));
assert!(!"Ferrös".eq_ignore_ascii_case("FERRÖS"));

pub fn make_ascii_uppercase(&mut self)

将此字符串就地转换为其 ASCII 大写等效项。

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

要返回新的大写值而不修改现有值，请使用 to_ascii_uppercase()。

Examples

let mut s = String::from("Grüße, Jürgen ❤");

s.make_ascii_uppercase();

assert_eq!("GRüßE, JüRGEN ❤", s);

pub fn make_ascii_lowercase(&mut self)

将此字符串就地转换为其 ASCII 小写等效项。

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

要返回新的小写值而不修改现有值，请使用 to_ascii_lowercase()。

Examples

let mut s = String::from("GRÜßE, JÜRGEN ❤");

s.make_ascii_lowercase();

assert_eq!("grÜße, jÜrgen ❤", s);

pub fn escape_debug(&self) -> EscapeDebug<'_>

返回一个迭代器，该迭代器使用 char::escape_debug 对 self 中的每个字符进行转义。

Note: 只有以字符串开头的扩展字素代码点将被转义。

Examples

作为迭代器：

for c in "❤\n!".escape_debug() {
    print!("{c}");
}
println!();

直接使用 println!：

println!("{}", "❤\n!".escape_debug());

两者都等同于：

println!("❤\\n!");

使用 to_string：

assert_eq!("❤\n!".escape_debug().to_string(), "❤\\n!");

pub fn escape_default(&self) -> EscapeDefault<'_>

返回一个迭代器，该迭代器使用 char::escape_default 对 self 中的每个字符进行转义。

Examples

作为迭代器：

for c in "❤\n!".escape_default() {
    print!("{c}");
}
println!();

直接使用 println!：

println!("{}", "❤\n!".escape_default());

两者都等同于：

println!("\\u{{2764}}\\n!");

使用 to_string：

assert_eq!("❤\n!".escape_default().to_string(), "\\u{2764}\\n!");

pub fn escape_unicode(&self) -> EscapeUnicode<'_>

返回一个迭代器，该迭代器使用 char::escape_unicode 对 self 中的每个字符进行转义。

Examples

作为迭代器：

for c in "❤\n!".escape_unicode() {
    print!("{c}");
}
println!();

直接使用 println!：

println!("{}", "❤\n!".escape_unicode());

两者都等同于：

println!("\\u{{2764}}\\u{{a}}\\u{{21}}");

使用 to_string：

assert_eq!("❤\n!".escape_unicode().to_string(), "\\u{2764}\\u{a}\\u{21}");

pub fn replace<'a, P>(&'a self, from: P, to: &str) -> Stringwhere P: Pattern<'a>,

用另一个字符串替换模式的所有匹配项。

replace 创建一个新的 String，并将此字符串切片中的数据复制到其中。 这样做时，它将尝试查找某个模式的匹配项。 如果找到，则将其替换为替换字符串切片。

Examples

基本用法：

let s = "this is old";

assert_eq!("this is new", s.replace("old", "new"));
assert_eq!("than an old", s.replace("is", "an"));

当模式不匹配时，它将此字符串切片作为 String 返回:

let s = "this is old";
assert_eq!(s, s.replace("cookie monster", "little lamb"));

pub fn replacen<'a, P>(&'a self, pat: P, to: &str, count: usize) -> Stringwhere P: Pattern<'a>,

用另一个字符串替换模式的前 N 个匹配项。

replacen 创建一个新的 String，并将此字符串切片中的数据复制到其中。 这样做时，它将尝试查找某个模式的匹配项。 如果找到任何内容，则最多 count 次将它们替换为替换字符串切片。

Examples

基本用法：

let s = "foo foo 123 foo";
assert_eq!("new new 123 foo", s.replacen("foo", "new", 2));
assert_eq!("faa fao 123 foo", s.replacen('o', "a", 3));
assert_eq!("foo foo new23 foo", s.replacen(char::is_numeric, "new", 1));

当模式不匹配时，它将此字符串切片作为 String 返回:

let s = "this is old";
assert_eq!(s, s.replacen("cookie monster", "little lamb", 10));

pub fn to_lowercase(&self) -> String

以新的 String 返回等效于此字符串切片的小写字母。

‘Lowercase’ 是根据 Unicode 派生核心属性 Lowercase 的术语定义的。

由于更改大小写时某些字符可以扩展为多个字符，因此此函数返回 String 而不是就地修改参数。

Examples

基本用法：

let s = "HELLO";

assert_eq!("hello", s.to_lowercase());

一个棘手的示例，使用 sigma：

let sigma = "Σ";

assert_eq!("σ", sigma.to_lowercase());

// 但在单词结尾时，它是 ς，而不是 σ：
let odysseus = "ὈΔΥΣΣΕΎΣ";

assert_eq!("ὀδυσσεύς", odysseus.to_lowercase());

不区分大小写的语言不会更改：

let new_year = "农历新年";

assert_eq!(new_year, new_year.to_lowercase());

pub fn to_uppercase(&self) -> String

返回此字符串切片的大写等效项，作为新的 String。

‘Uppercase’ 是根据 Unicode 派生核心属性 Uppercase 的术语定义的。

由于更改大小写时某些字符可以扩展为多个字符，因此此函数返回 String 而不是就地修改参数。

Examples

基本用法：

let s = "hello";

assert_eq!("HELLO", s.to_uppercase());

不区分大小写的脚本不会更改：

let new_year = "农历新年";

assert_eq!(new_year, new_year.to_uppercase());

一个字符可以变成多个：

let s = "tschüß";

assert_eq!("TSCHÜSS", s.to_uppercase());

pub fn repeat(&self, n: usize) -> String

通过重复字符串 n 次来创建新的 String。

Panics

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

Examples

基本用法：

assert_eq!("abc".repeat(4), String::from("abcabcabcabc"));

溢出时为 panic：

// 这将在运行时 panic
let huge = "0123456789abcdef".repeat(usize::MAX);

pub fn to_ascii_uppercase(&self) -> String

返回此字符串的副本，其中每个字符都映射为其等效的 ASCII 大写字母。

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

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

要除非 ASCII 字符外还使用大写 ASCII 字符，请使用 to_uppercase。

Examples

let s = "Grüße, Jürgen ❤";

assert_eq!("GRüßE, JüRGEN ❤", s.to_ascii_uppercase());

pub fn to_ascii_lowercase(&self) -> String

返回此字符串的副本，其中每个字符都映射为其等效的 ASCII 小写字母。

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

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

要除非 ASCII 字符外还使用小写 ASCII 字符，请使用 to_lowercase。

Examples

let s = "Grüße, Jürgen ❤";

assert_eq!("grüße, jürgen ❤", s.to_ascii_lowercase());

Trait Implementations

impl Add<&str> for String

实现 + 运算符以连接两个字符串。

这会消费左侧的 String，并重新使用其缓冲区 (如有必要，请增加缓冲区)。 这样做是为了避免分配新的 String 并在每个操作上复制整个内容，当通过重复连接构建 n 字节的字符串时，这将导致 O(n^ 2) 运行时间。

右侧的字符串仅是借用的。它的内容被复制到返回的 String 中。

Examples

将两个 String 连接起来，第一个按值取值，第二个借用：

let a = String::from("hello");
let b = String::from(" world");
let c = a + &b;
// `a` 已移动，不能再在此处使用。

如果要继续使用第一个 String，则可以对其进行克隆并追加到克隆中：

let a = String::from("hello");
let b = String::from(" world");
let c = a.clone() + &b;
// `a` 在这里仍然有效。

可以通过将第一个切片转换为 String 来完成 &str 切片的连接：

let a = "hello";
let b = " world";
let c = a.to_string() + b;

type Output = String

应用 + 运算符后的结果类型。

fn add(self, other: &str) -> String

执行 + 操作。

impl AddAssign<&str> for String

实现用于追加到 String 的 += 运算符。

这与 push_str 方法具有相同的行为。

fn add_assign(&mut self, other: &str)

执行 += 操作。

impl AsMut<str> for String

fn as_mut(&mut self) -> &mut str

将此类型转换为 (通常是推断的) 输入类型的错误引用。

impl AsRef<[u8]> for String

fn as_ref(&self) -> &[u8]

将此类型转换为 (通常是推断的) 输入类型的共享引用。

impl AsRef<OsStr> for String

fn as_ref(&self) -> &OsStr

将此类型转换为 (通常是推断的) 输入类型的共享引用。

impl AsRef<Path> for String

fn as_ref(&self) -> &Path

将此类型转换为 (通常是推断的) 输入类型的共享引用。

impl AsRef<str> for String

fn as_ref(&self) -> &str

将此类型转换为 (通常是推断的) 输入类型的共享引用。

impl Borrow<str> for String

fn borrow(&self) -> &str

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

impl BorrowMut<str> for String

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

从拥有的值中借用。

impl Clone for String

fn clone(&self) -> String

返回值的副本。

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

从 source 执行复制分配。

impl Debug for String

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

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

impl Default for String

fn default() -> String

创建一个空的 String。

impl Deref for String

type Target = str

解引用后的结果类型。

fn deref(&self) -> &str

解引用值。

impl DerefMut for String

fn deref_mut(&mut self) -> &mut str

可变地解引用该值。

impl Display for String

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

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

impl<'a> Extend<&'a char> for String

fn extend<I>(&mut self, iter: I)where I: IntoIterator<Item = &'a char>,

使用迭代器的内容扩展集合。

fn extend_one(&mut self, _: &'a char)

🔬This is a nightly-only experimental API. (extend_one #72631)

用一个元素扩展一个集合。

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one #72631)

在集合中为给定数量的附加元素保留容量。

impl<'a> Extend<&'a str> for String

fn extend<I>(&mut self, iter: I)where I: IntoIterator<Item = &'a str>,

使用迭代器的内容扩展集合。

fn extend_one(&mut self, s: &'a str)

🔬This is a nightly-only experimental API. (extend_one #72631)

用一个元素扩展一个集合。

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one #72631)

在集合中为给定数量的附加元素保留容量。

impl Extend<Box<str, Global>> for String

fn extend<I>(&mut self, iter: I)where I: IntoIterator<Item = Box<str, Global>>,

使用迭代器的内容扩展集合。

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one #72631)

用一个元素扩展一个集合。

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one #72631)

在集合中为给定数量的附加元素保留容量。

impl<'a> Extend<Cow<'a, str>> for String

fn extend<I>(&mut self, iter: I)where I: IntoIterator<Item = Cow<'a, str>>,

使用迭代器的内容扩展集合。

fn extend_one(&mut self, s: Cow<'a, str>)

🔬This is a nightly-only experimental API. (extend_one #72631)

用一个元素扩展一个集合。

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one #72631)

在集合中为给定数量的附加元素保留容量。

impl Extend<String> for String

fn extend<I>(&mut self, iter: I)where I: IntoIterator<Item = String>,

使用迭代器的内容扩展集合。

fn extend_one(&mut self, s: String)

🔬This is a nightly-only experimental API. (extend_one #72631)

用一个元素扩展一个集合。

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one #72631)

在集合中为给定数量的附加元素保留容量。

impl Extend<char> for String

fn extend<I>(&mut self, iter: I)where I: IntoIterator<Item = char>,

使用迭代器的内容扩展集合。

fn extend_one(&mut self, c: char)

🔬This is a nightly-only experimental API. (extend_one #72631)

用一个元素扩展一个集合。

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one #72631)

在集合中为给定数量的附加元素保留容量。

impl<'a> From<&'a String> for Cow<'a, str>

fn from(s: &'a String) -> Cow<'a, str>

将 String 引用转换为 Borrowed 变体。 不执行堆分配，并且不复制字符串。

Example

let s = "eggplant".to_string();
assert_eq!(Cow::from(&s), Cow::Borrowed("eggplant"));

impl From<&String> for String

fn from(s: &String) -> String

将 &String 转换为 String。

这将克隆 s 并返回该克隆。

impl From<&mut str> for String

fn from(s: &mut str) -> String

将 &mut str 转换为 String。

结果分配在堆上。

impl From<&str> for String

fn from(s: &str) -> String

将 &str 转换为 String。

结果分配在堆上。

impl From<Box<str, Global>> for String

fn from(s: Box<str, Global>) -> String

将给定的 boxed str 切片转换为 String。 值得注意的是，str 切片是拥有的。

Examples

基本用法：

let s1: String = String::from("hello world");
let s2: Box<str> = s1.into_boxed_str();
let s3: String = String::from(s2);

assert_eq!("hello world", s3)

impl<'a> From<Cow<'a, str>> for String

fn from(s: Cow<'a, str>) -> String

将写时克隆字符串转换为 String 的拥有实例。

这将提取拥有所有权的字符串，如果尚未拥有，则克隆该字符串。

Example

// 如果字符串不被拥有...
let cow: Cow<'_, str> = Cow::Borrowed("eggplant");
// 它将在堆上分配并复制字符串。
let owned: String = String::from(cow);
assert_eq!(&owned[..], "eggplant");

impl From<String> for Arc<str>

fn from(v: String) -> Arc<str>

分配一个引用计数的 str 并将 v 复制到其中。

Example

let unique: String = "eggplant".to_owned();
let shared: Arc<str> = Arc::from(unique);
assert_eq!("eggplant", &shared[..]);

impl From<String> for Box<dyn Error + 'static, Global>

fn from(str_err: String) -> Box<dyn Error + 'static, Global>

将 String 转换为 dyn Error 的 box。

Examples

use std::error::Error;
use std::mem;

let a_string_error = "a string error".to_string();
let a_boxed_error = Box::<dyn Error>::from(a_string_error);
assert!(mem::size_of::<Box<dyn Error>>() == mem::size_of_val(&a_boxed_error))

impl From<String> for Box<dyn Error + Send + Sync + 'static, Global>

fn from(err: String) -> Box<dyn Error + Send + Sync + 'static, Global>

将 String 转换为 Dyn Error + Send + Sync 的 box。

Examples

use std::error::Error;
use std::mem;

let a_string_error = "a string error".to_string();
let a_boxed_error = Box::<dyn Error + Send + Sync>::from(a_string_error);
assert!(
    mem::size_of::<Box<dyn Error + Send + Sync>>() == mem::size_of_val(&a_boxed_error))

impl From<String> for Box<str, Global>

fn from(s: String) -> Box<str, Global>

将给定的 String 转换为拥有所有权的 boxed str 切片。

Examples

基本用法：

let s1: String = String::from("hello world");
let s2: Box<str> = Box::from(s1);
let s3: String = String::from(s2);

assert_eq!("hello world", s3)

impl<'a> From<String> for Cow<'a, str>

fn from(s: String) -> Cow<'a, str>

将 String 转换为 Owned 变体。 不执行堆分配，并且不复制字符串。

Example

let s = "eggplant".to_string();
let s2 = "eggplant".to_string();
assert_eq!(Cow::from(s), Cow::<'static, str>::Owned(s2));

impl From<String> for OsString

fn from(s: String) -> OsString

将 String 转换为 OsString。

此转换不会分配或复制内存。

impl From<String> for PathBuf

fn from(s: String) -> PathBuf

将 String 转换为 PathBuf

此转换不会分配或复制内存。

impl From<String> for Rc<str>

fn from(v: String) -> Rc<str>

分配一个引用计数的字符串切片并将 v 复制到其中。

Example

let original: String = "statue".to_owned();
let shared: Rc<str> = Rc::from(original);
assert_eq!("statue", &shared[..]);

impl From<String> for Vec<u8, Global>

fn from(string: String) -> Vec<u8, Global>

将给定的 String 转换为包含 u8 类型值的 vector Vec。

Examples

基本用法：

let s1 = String::from("hello world");
let v1 = Vec::from(s1);

for b in v1 {
    println!("{b}");
}

impl From<char> for String

fn from(c: char) -> String

从单个字符分配一个拥有所有权的 String。

Example

let c: char = 'a';
let s: String = String::from(c);
assert_eq!("a", &s[..]);

impl<'a> FromIterator<&'a char> for String

fn from_iter<I>(iter: I) -> Stringwhere I: IntoIterator<Item = &'a char>,

从迭代器创建一个值。

impl<'a> FromIterator<&'a str> for String

fn from_iter<I>(iter: I) -> Stringwhere I: IntoIterator<Item = &'a str>,

从迭代器创建一个值。

impl FromIterator<Box<str, Global>> for String

fn from_iter<I>(iter: I) -> Stringwhere I: IntoIterator<Item = Box<str, Global>>,

从迭代器创建一个值。

impl<'a> FromIterator<Cow<'a, str>> for String

fn from_iter<I>(iter: I) -> Stringwhere I: IntoIterator<Item = Cow<'a, str>>,

从迭代器创建一个值。

impl<'a> FromIterator<String> for Cow<'a, str>

fn from_iter<I>(it: I) -> Cow<'a, str>where I: IntoIterator<Item = String>,

从迭代器创建一个值。

impl FromIterator<String> for String

fn from_iter<I>(iter: I) -> Stringwhere I: IntoIterator<Item = String>,

从迭代器创建一个值。

impl FromIterator<char> for String

fn from_iter<I>(iter: I) -> Stringwhere I: IntoIterator<Item = char>,

从迭代器创建一个值。

impl FromStr for String

type Err = Infallible

可以从解析中返回的相关错误。

fn from_str(s: &str) -> Result<String, <String as FromStr>::Err>

解析字符串 s 以返回此类型的值。

impl Hash for String

fn hash<H>(&self, hasher: &mut H)where H: Hasher,

将该值输入给定的 Hasher。

fn hash_slice<H>(data: &[Self], state: &mut H)where H: Hasher, Self: Sized,

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

impl Index<Range<usize>> for String

type Output = str

索引后返回的类型。

fn index(&self, index: Range<usize>) -> &str

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

impl Index<RangeFrom<usize>> for String

type Output = str

索引后返回的类型。

fn index(&self, index: RangeFrom<usize>) -> &str

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

impl Index<RangeFull> for String

type Output = str

索引后返回的类型。

fn index(&self, _index: RangeFull) -> &str

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

impl Index<RangeInclusive<usize>> for String

type Output = str

索引后返回的类型。

fn index(&self, index: RangeInclusive<usize>) -> &str

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

impl Index<RangeTo<usize>> for String

type Output = str

索引后返回的类型。

fn index(&self, index: RangeTo<usize>) -> &str

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

impl Index<RangeToInclusive<usize>> for String

type Output = str

索引后返回的类型。

fn index(&self, index: RangeToInclusive<usize>) -> &str

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

impl IndexMut<Range<usize>> for String

fn index_mut(&mut self, index: Range<usize>) -> &mut str

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

impl IndexMut<RangeFrom<usize>> for String

fn index_mut(&mut self, index: RangeFrom<usize>) -> &mut str

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

impl IndexMut<RangeFull> for String

fn index_mut(&mut self, _index: RangeFull) -> &mut str

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

impl IndexMut<RangeInclusive<usize>> for String

fn index_mut(&mut self, index: RangeInclusive<usize>) -> &mut str

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

impl IndexMut<RangeTo<usize>> for String

fn index_mut(&mut self, index: RangeTo<usize>) -> &mut str

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

impl IndexMut<RangeToInclusive<usize>> for String

fn index_mut(&mut self, index: RangeToInclusive<usize>) -> &mut str

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

impl Ord for String

fn cmp(&self, other: &String) -> Ordering

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

fn max(self, other: Self) -> Selfwhere Self: Sized,

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

fn min(self, other: Self) -> Selfwhere Self: Sized,

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

fn clamp(self, min: Self, max: Self) -> Selfwhere Self: Sized + PartialOrd<Self>,

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

impl<'a, 'b> PartialEq<&'a str> for String

fn eq(&self, other: &&'a str) -> bool

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

fn ne(&self, other: &&'a str) -> bool

此方法测试 !=。 默认实现几乎总是足够的，并且不应在没有充分理由的情况下被覆盖。

impl<'a, 'b> PartialEq<Cow<'a, str>> for String

fn eq(&self, other: &Cow<'a, str>) -> bool

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

fn ne(&self, other: &Cow<'a, str>) -> bool

此方法测试 !=。 默认实现几乎总是足够的，并且不应在没有充分理由的情况下被覆盖。

impl<'a, 'b> PartialEq<String> for &'a str

fn eq(&self, other: &String) -> bool

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

fn ne(&self, other: &String) -> bool

此方法测试 !=。 默认实现几乎总是足够的，并且不应在没有充分理由的情况下被覆盖。

impl<'a, 'b> PartialEq<String> for Cow<'a, str>

fn eq(&self, other: &String) -> bool

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

fn ne(&self, other: &String) -> bool

此方法测试 !=。 默认实现几乎总是足够的，并且不应在没有充分理由的情况下被覆盖。

impl PartialEq<String> for String

fn eq(&self, other: &String) -> bool

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

fn ne(&self, other: &Rhs) -> bool

此方法测试 !=。 默认实现几乎总是足够的，并且不应在没有充分理由的情况下被覆盖。

impl<'a, 'b> PartialEq<String> for str

fn eq(&self, other: &String) -> bool

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

fn ne(&self, other: &String) -> bool

此方法测试 !=。 默认实现几乎总是足够的，并且不应在没有充分理由的情况下被覆盖。

impl<'a, 'b> PartialEq<str> for String

fn eq(&self, other: &str) -> bool

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

fn ne(&self, other: &str) -> bool

此方法测试 !=。 默认实现几乎总是足够的，并且不应在没有充分理由的情况下被覆盖。

impl PartialOrd<String> for String

fn partial_cmp(&self, other: &String) -> Option<Ordering>

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

fn lt(&self, other: &Rhs) -> bool

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

fn le(&self, other: &Rhs) -> bool

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

fn gt(&self, other: &Rhs) -> bool

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

fn ge(&self, other: &Rhs) -> bool

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

impl<'a, 'b> Pattern<'a> for &'b String

一个方便的 impl，委派给 &str 的 impl。

Examples

assert_eq!(String::from("Hello world").find("world"), Some(6));

type Searcher = <&'b str as Pattern<'a>>::Searcher

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

此模式的关联搜索者

fn into_searcher(self, haystack: &'a str) -> <&'b str as Pattern<'a>>::Searcher

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

从 self 和 haystack 构造关联的搜索器以进行搜索。

fn is_contained_in(self, haystack: &'a str) -> bool

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

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

fn is_prefix_of(self, haystack: &'a str) -> bool

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

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

fn strip_prefix_of(self, haystack: &'a str) -> Option<&'a str>

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

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

fn is_suffix_of(self, haystack: &'a str) -> bool

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

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

fn strip_suffix_of(self, haystack: &'a str) -> Option<&'a str>

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

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

impl ToSocketAddrs for String

type Iter = IntoIter<SocketAddr, Global>

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

fn to_socket_addrs(&self) -> Result<IntoIter<SocketAddr>>

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

impl ToString for String

fn to_string(&self) -> String

将给定值转换为 String。

impl Write for String

fn write_str(&mut self, s: &str) -> Result<(), Error>

将字符串切片写入此 writer，返回写入是否成功。

fn write_char(&mut self, c: char) -> Result<(), Error>

将 char 写入此 writer，返回写入是否成功。

fn write_fmt(&mut self, args: Arguments<'_>) -> Result<(), Error>

结合使用 write! 宏和 trait 的实现者。

impl Eq for String

impl StructuralEq for String

impl StructuralPartialEq for String