Primitive Type str1.0.0[]

Expand description

字符串切片。

See also the std::str module.

str 类型,也称为字符串切片,是最原始的字符串类型。 它通常以其借用形式 &str 出现。 也是字符串字面量的类型,&'static str

字符串切片始终是有效的 UTF-8。

Examples

字符串字面量是字符串切片:

let hello = "Hello, world!";

// 带有明确的类型注解
let hello: &'static str = "Hello, world!";
Run

它们是 'static,因为它们直接存储在最终二进制文件中,因此在 'static 持续时间内有效。

Representation

&str 由两个部分组成:一个指向某些字节的指针和一个长度。 您可以使用 as_ptrlen 方法查看它们:

use std::slice;
use std::str;

let story = "Once upon a time...";

let ptr = story.as_ptr();
let len = story.len();

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

// 我们可以根据 ptr 和 len 重新构建一个 str。
// 这都是不安全的,因为我们有责任确保两个组件均有效:
let s = unsafe {
    // 首先,我们建立一个 &[u8] ...
    let slice = slice::from_raw_parts(ptr, len);

    // ... 然后将该切片转换为字符串
    str::from_utf8(slice)
};

assert_eq!(s, Ok(story));
Run

Note: 本示例显示了 &str 的内部结构。 在正常情况下,不应使用 unsafe 来获取字符串切片。 请改用 as_str

Implementations

返回 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

Trait Implementations

执行转换。

执行转换。

执行转换。

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

创建一个空的 str

创建一个空的可变 str

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

将该值输入给定的 HasherRead more

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

索引后返回的类型。

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

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

实现字符串排序。

字符串按字节值按 按字典顺序 排序。 这将根据 Unicode 代码点在代码图中的位置进行排序。 这不一定与 “alphabetical” 顺序相同,后者因语言和区域设置而异。 根据文化认可的标准对字符串进行排序需要 str 类型的作用域之外的特定于语言环境的数据。

此方法返回 selfother 之间的 OrderingRead more

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

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

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

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

此方法测试 !=

对字符串执行比较操作。

按字典顺序 通过字符串的字节值对字符串进行比较。 这将根据 Unicode 代码点在代码表中的位置进行比较。 这不一定与 “alphabetical” 顺序相同,后者因语言和区域设置而异。 根据文化认可的标准比较字符串需要特定于语言环境的数据,该数据不在 str 类型的作用域之内。

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

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

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

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

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

非分配子字符串搜索。

将模式 "" 处理为在每个字符边界处返回空匹配项。

Examples

assert_eq!("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

检查模式在 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

此模式的关联搜索者

🔬 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 中的任何位置匹配