Struct std::string::String1.0.0[][src]

pub struct String { /* fields omitted */ }
Expand description

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

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

Examples

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

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

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

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

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

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

UTF-8

Strings 始终是有效的 UTF-8。这有一些含义,首先是如果您需要非 UTF-8 字符串,请考虑使用 OsString。它是相似的,但是没有 UTF-8 约束。第二个含义是您不能索引到 String

let s = "hello";

println!("The first letter of s is {}", s[0]); // ERROR!!!
Run

索引旨在进行恒定时间操作,但是 UTF-8 编码不允许我们执行此操作。此外,尚不清楚索引应返回哪种类型:字节,代码点或字形簇。 byteschars 方法分别返回前两个的迭代器。

Deref

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

fn takes_str(s: &str) { }

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

takes_str(&s);
Run

这将从 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);
Run

有两种选择可以代替。第一种是使用方法 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_ptrlencapacity 方法查看它们:

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

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

let mut s = String::new();

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

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

这将输出以下内容:

0
5
10
20
20
40

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

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

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

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

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

25
25
25
25
25
25

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

Implementations

创建一个新的空 String

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

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

Examples

基本用法:

let s = String::new();
Run

创建一个具有特定容量的新的空 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');
Run

将字节的 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);
Run

字节不正确:

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

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

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

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

字符串由字节 (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);
Run

字节不正确:

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

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

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

将 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));
Run
🔬 This is a nightly-only experimental API. (vec_into_raw_parts #65816)

new API

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

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

Safety

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

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

违反这些可能会导致一些问题,比如破坏分配器的内部数据结构。

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

将字节的 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);
Run

String 转换为字节 vector。

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

Examples

基本用法:

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

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

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

Examples

基本用法:

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

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

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

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

Examples

基本用法:

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

s.push_str("bar");

assert_eq!("foobar", s);
Run
🔬 This is a nightly-only experimental API. (string_extend_from_within)

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

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

Examples

基本用法:

let s = String::with_capacity(10);

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

确保此 String 的容量至少比其长度大 additional 字节。

如果选择,容量可能会增加 additional 字节以上,以防止频繁重新分配。

如果您不希望这种 “at least” 行为,请参见 reserve_exact 方法。

Panics

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

Examples

基本用法:

let mut s = String::new();

s.reserve(10);

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

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

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

// s 现在的长度为 2,容量为 10
assert_eq!(2, s.len());
assert_eq!(10, s.capacity());

// 由于我们已经有 8 个额外的容量,因此称此为...
s.reserve(8);

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

确保此 String 的容量比其长度大 additional 字节。

除非您绝对比分配器更了解,否则请考虑使用 reserve 方法。

Panics

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

Examples

基本用法:

let mut s = String::new();

s.reserve_exact(10);

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

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

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

// s 现在的长度为 2,容量为 10
assert_eq!(2, s.len());
assert_eq!(10, s.capacity());

// 由于我们已经有 8 个额外的容量,因此称此为...
s.reserve_exact(8);

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

尝试为给 String 至少插入 additional 个元素保留容量。 该集合可以保留更多空间,以避免频繁的重新分配。 调用 reserve 后,容量将大于或等于 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)
}
Run

尝试保留最小容量,以便在给定的 String 中精确插入 additional 个元素。

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

请注意,分配器可能会给集合提供比其请求更多的空间。 因此,不能依靠容量来精确地最小化。 如果预计将来会插入,则最好使用 reserve

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

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

Examples

基本用法:

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

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

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

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

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

Examples

基本用法:

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

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

assert_eq!("abc123", s);
Run

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

与此方法的相反的是 from_utf8

Examples

基本用法:

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

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

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

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

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

Panics

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

Examples

基本用法:

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

s.truncate(2);

assert_eq!("he", s);
Run

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

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

从该 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');
Run
🔬 This is a nightly-only experimental API. (string_remove_matches #72826)

new API

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

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

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

仅保留谓词指定的字符。

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

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

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

assert_eq!(s, "foobar");
Run

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

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

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

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

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

Panics

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

Examples

基本用法:

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

s.insert_str(0, "foo");

assert_eq!("foobar", s);
Run

返回此 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");
Run

返回此 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);
Run

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

Examples

基本用法:

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

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

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

返回新分配的 Stringself 包含字节 [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!");
Run

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

创建一个 draining 迭代器,该迭代器将删除 String 中的指定范围并产生已删除的 chars

Note: 即使迭代器直到最后才被消耗,元素范围也会被删除。

Panics

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

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

// 全范围清除字符串
s.drain(..);
assert_eq!(s, "");
Run

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

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

将此 String 转换为 Box<str>

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

Examples

基本用法:

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

let b = s.into_boxed_str();
Run

Methods from Deref<Target = str>

返回 self 的长度。

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

Examples

基本用法:

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

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

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

Examples

基本用法:

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

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

检查第 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));
Run

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

Examples

基本用法:

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

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

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

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

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

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

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

Examples

基本用法:

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

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

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

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

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

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

返回未经检查的 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));
}
Run

返回 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));
}
Run
👎 Deprecated since 1.29.0:

use get_unchecked(begin..end) instead

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

通常不建议这样做,请谨慎使用! 有关安全的替代方法,请参见 strIndex

此新切片从 beginend,包括 begin 但不包括 end

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

Safety

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

  • begin 不得超过 end
  • beginend 必须是字符串切片内的字节位置。
  • beginend 必须位于 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));
}
Run
👎 Deprecated since 1.29.0:

use get_unchecked_mut(begin..end) instead

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

此新切片从 beginend,包括 begin 但不包括 end

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

Safety

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

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

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

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

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

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

返回字符串切片的 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());
Run

请记住,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());
Run

返回字符串切片的 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());
Run

请记住,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());
Run

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

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

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

用空格分割字符串切片。

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

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

考虑所有类型的空白:

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

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

考虑所有类型的 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());
Run

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

行以换行符 (\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());
Run

不需要最后一行:

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());
Run
👎 Deprecated since 1.4.0:

use lines() instead now

字符串行上的迭代器。

在编码为 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);
Run

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

如果不是,则返回 false

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

Examples

基本用法:

let bananas = "bananas";

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

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

如果不是,则返回 false

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

Examples

基本用法:

let bananas = "bananas";

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

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

如果不是,则返回 false

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

Examples

基本用法:

let bananas = "bananas";

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

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

如果模式不匹配,则返回 None

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

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

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

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

找不到模式:

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

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

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

如果模式不匹配,则返回 None

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

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

闭包的更复杂模式:

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

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

找不到模式:

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

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

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

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

迭代器行为

如果模式允许反向搜索且 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"]);
Run

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

它确实不会给您:

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

为此行为使用 split_whitespace

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

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

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

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

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

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

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

迭代器行为

返回的迭代器要求模式支持反向搜索,如果 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"]);
Run

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

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

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

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

等效于 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"]);
Run

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

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

等效于 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"]);
Run

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

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

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

迭代器行为

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

如果模式允许反向搜索,则可以使用 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, [""]);
Run

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

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

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

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

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

迭代器行为

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

要从正面拆分,可以使用 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"]);
Run

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

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

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

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

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

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

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

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

迭代器行为

如果模式允许反向搜索且 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"]);
Run

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

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

迭代器行为

返回的迭代器要求模式支持反向搜索,如果 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"]);
Run

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

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

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

迭代器行为

如果模式允许反向搜索且 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`
Run

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

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

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

迭代器行为

返回的迭代器要求模式支持反向搜索,如果 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`
Run

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

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

Examples

基本用法:

let s = " Hello\tworld\t";

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

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

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

文字方向性

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

Examples

基本用法:

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

Directionality:

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

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

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

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

文字方向性

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

Examples

基本用法:

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

Directionality:

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

let s = "  עברית  ";
assert!(Some('ת') == s.trim_end().chars().rev().next());
Run
👎 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());
Run

Directionality:

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

let s = "  עברית";
assert!(Some('ע') == s.trim_left().chars().next());
Run
👎 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());
Run

Directionality:

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

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

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

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

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

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

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

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

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

文字方向性

字符串是字节序列。 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");
Run

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

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

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

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

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

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

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

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

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

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

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

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

文字方向性

字符串是字节序列。 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");
Run

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

assert_eq!("1fooX".trim_end_matches(|c| c == '1' || c == 'X'), "1foo");
Run
👎 Deprecated since 1.33.0:

superseded by trim_start_matches

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

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

文字方向性

字符串是字节序列。 ‘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");
Run
👎 Deprecated since 1.33.0:

superseded by trim_end_matches

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

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

文字方向性

字符串是字节序列。 ‘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");
Run

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

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

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

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

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

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

Errors

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

Examples

基本用法

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

assert_eq!(4, four);
Run

使用 ‘turbofish’ 而不是注解 four

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

assert_eq!(Ok(4), four);
Run

无法解析:

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

assert!(nope.is_err());
Run

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

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

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

检查两个字符串是否为 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"));
Run

将此字符串就地转换为其 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);
Run

将此字符串就地转换为其 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);
Run

返回一个迭代器,该迭代器使用 char::escape_debugself 中的每个字符进行转义。

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

Examples

作为迭代器:

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

直接使用 println!

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

两者都等同于:

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

使用 to_string

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

返回一个迭代器,该迭代器使用 char::escape_defaultself 中的每个字符进行转义。

Examples

作为迭代器:

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

直接使用 println!

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

两者都等同于:

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

使用 to_string

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

返回一个迭代器,该迭代器使用 char::escape_unicodeself 中的每个字符进行转义。

Examples

作为迭代器:

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

直接使用 println!

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

两者都等同于:

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

使用 to_string

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

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

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

Examples

基本用法:

let s = "this is old";

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

当模式不匹配时:

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

用另一个字符串替换模式的前 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));
Run

当模式不匹配时:

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

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

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

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

Examples

基本用法:

let s = "HELLO";

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

一个棘手的示例,使用 sigma:

let sigma = "Σ";

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

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

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

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

let new_year = "农历新年";

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

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

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

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

Examples

基本用法:

let s = "hello";

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

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

let new_year = "农历新年";

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

一个字符可以变成多个:

let s = "tschüß";

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

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

Panics

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

Examples

基本用法:

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

溢出时为 panic:

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

返回此字符串的副本,其中每个字符都映射为其等效的 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());
Run

返回此字符串的副本,其中每个字符都映射为其等效的 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());
Run

Trait Implementations

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

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

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

Examples

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

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

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

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

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

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

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

执行 + 操作。 Read more

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

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

执行 += 操作。 Read more

执行转换。

执行转换。

执行转换。

执行转换。

执行转换。

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

从拥有的值中借用。 Read more

返回值的副本。 Read more

source 执行复制分配。 Read more

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

创建一个空的 String

解引用后的结果类型。

解引用值。

可变地解引用该值。

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

使用迭代器的内容扩展集合。 Read more

🔬 This is a nightly-only experimental API. (extend_one #72631)

用一个元素扩展一个集合。

🔬 This is a nightly-only experimental API. (extend_one #72631)

在集合中为给定数量的附加元素保留容量。 Read more

使用迭代器的内容扩展集合。 Read more

🔬 This is a nightly-only experimental API. (extend_one #72631)

用一个元素扩展一个集合。

🔬 This is a nightly-only experimental API. (extend_one #72631)

在集合中为给定数量的附加元素保留容量。 Read more

使用迭代器的内容扩展集合。 Read more

🔬 This is a nightly-only experimental API. (extend_one #72631)

用一个元素扩展一个集合。

🔬 This is a nightly-only experimental API. (extend_one #72631)

在集合中为给定数量的附加元素保留容量。 Read more

使用迭代器的内容扩展集合。 Read more

🔬 This is a nightly-only experimental API. (extend_one #72631)

用一个元素扩展一个集合。

🔬 This is a nightly-only experimental API. (extend_one #72631)

在集合中为给定数量的附加元素保留容量。 Read more

使用迭代器的内容扩展集合。 Read more

🔬 This is a nightly-only experimental API. (extend_one #72631)

用一个元素扩展一个集合。

🔬 This is a nightly-only experimental API. (extend_one #72631)

在集合中为给定数量的附加元素保留容量。 Read more

使用迭代器的内容扩展集合。 Read more

🔬 This is a nightly-only experimental API. (extend_one #72631)

用一个元素扩展一个集合。

🔬 This is a nightly-only experimental API. (extend_one #72631)

在集合中为给定数量的附加元素保留容量。 Read more

&String 转换为 String

这将克隆 s 并返回该克隆。

&mut str 转换为 String

结果分配在堆上。

&str 转换为 String

结果分配在堆上。

String 引用转换为 Borrowed 变体。 不执行堆分配,并且不复制字符串。

Example
let s = "eggplant".to_string();
assert_eq!(Cow::from(&s), Cow::Borrowed("eggplant"));
Run

将给定的 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)
Run

将写时克隆字符串转换为 String 的拥有实例。

这将提取拥有所有权的字符串,如果尚未拥有,则克隆该字符串。

Example
// 如果该字符串不被拥有...
let cow: Cow<str> = Cow::Borrowed("eggplant");
// 它将在堆上分配并复制字符串。
let owned: String = String::from(cow);
assert_eq!(&owned[..], "eggplant");
Run

String 转换为 Owned 变体。 不执行堆分配,并且不复制字符串。

Example
let s = "eggplant".to_string();
let s2 = "eggplant".to_string();
assert_eq!(Cow::from(s), Cow::<'static, str>::Owned(s2));
Run

将给定的 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)
Run

分配一个引用计数的 str 并将 v 复制到其中。

Example
let unique: String = "eggplant".to_owned();
let shared: Arc<str> = Arc::from(unique);
assert_eq!("eggplant", &shared[..]);
Run

将给定的 String 转换为包含 u8 类型值的 vector Vec

Examples

基本用法:

let s1 = String::from("hello world");
let v1 = Vec::from(s1);

for b in v1 {
    println!("{}", b);
}
Run

分配一个引用计数的字符串切片并将 v 复制到其中。

Example
let original: String = "statue".to_owned();
let shared: Rc<str> = Rc::from(original);
assert_eq!("statue", &shared[..]);
Run

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

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

String 转换为 OsString

此转换不会分配或复制内存。

String 转换为 PathBuf

此转换不会分配或复制内存。

从单个字符分配一个拥有所有权的 String

Example
let c: char = 'a';
let s: String = String::from(c);
assert_eq!("a", &s[..]);
Run

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

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

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

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

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

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

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

可以从解析中返回的相关错误。

解析字符串 s 以返回此类型的值。 Read more

将该值输入给定的 HasherRead more

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

索引后返回的类型。

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

索引后返回的类型。

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

索引后返回的类型。

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

索引后返回的类型。

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

索引后返回的类型。

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

索引后返回的类型。

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

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

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

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

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

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

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

此方法返回 selfother 之间的 OrderingRead more

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

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

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

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

此方法测试 !=

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

此方法测试 !=

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

此方法测试 !=

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

此方法测试 !=

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

此方法测试 !=

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

此方法测试 !=

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

此方法测试 !=

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

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

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

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

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

一个方便的 impl,委派给 &str 的 impl。

Examples

assert_eq!(String::from("Hello world").find("world"), Some(6));
Run
🔬 This is a nightly-only experimental API. (pattern #27721)

API not fully fleshed out and ready to be stabilized

此模式的关联搜索者

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

API not fully fleshed out and ready to be stabilized

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

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

API not fully fleshed out and ready to be stabilized

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

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

API not fully fleshed out and ready to be stabilized

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

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

API not fully fleshed out and ready to be stabilized

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

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

API not fully fleshed out and ready to be stabilized

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

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

API not fully fleshed out and ready to be stabilized

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

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

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

将给定值转换为 StringRead more

将字符串切片写入此 writer,返回写入是否成功。 Read more

char 写入此 writer,返回写入是否成功。 Read more

结合使用 write! 宏和 trait 的实现者。 Read more

Auto Trait Implementations

Blanket Implementations

获取 selfTypeIdRead more

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

从拥有的值中借用。 Read more

执行转换。

执行转换。

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

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

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

recently added

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

将给定值转换为 StringRead more

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

执行转换。

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

执行转换。