Primitive Type str

1.0.0 ·
Expand description

字符串切片。

See also the std::str module.

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

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

基本用法

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

let hello_world = "Hello, World!";
Run

这里我们声明了一个用字符串字面量初始化的字符串切片。 字符串字面量具有静态的生命周期，这意味着字符串 hello_world 在整个程序期间均有效。

我们也可以明确指定 hello_world 的生命周期：

let hello_world: &'static str = "Hello, world!";
Run

Representation

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

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§

source§

impl str

const: 1.39.0 · source

pub const 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);
Run
const: 1.39.0 · source

pub const fn is_empty(&self) -> bool

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

Examples

基本用法：

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

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

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

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], "❤️🧡");
Run
source

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], "❤️🧡💛");
Run
const: 1.39.0 · source

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

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

Examples

基本用法：

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

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);
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
const: 1.32.0 · source

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

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

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

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

Examples

基本用法：

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

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

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

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

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

1.20.0 · source

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

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);
Run
1.20.0 · source

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

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

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

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 序列边界上。
1.4.0 · source

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);
Run
1.4.0 · source

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

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

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

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

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

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

assert_eq!("".split_whitespace().next(), None);
assert_eq!("   ".split_whitespace().next(), None);
Run
1.34.0 · source

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

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

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

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

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

👎Deprecated since 1.4.0: use lines() instead now

字符串行上的迭代器。

1.8.0 · source

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

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

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

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

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

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

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

1.51.0 · source

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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`
Run
1.5.0 · source

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`
Run
source

pub fn trim(&self) -> &str

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

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

Examples

基本用法：

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

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

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

Directionality:

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

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

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

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

Directionality:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

无法解析：

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

assert!(nope.is_err());
Run
1.23.0 (const: unstable) · source

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

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

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

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

1.23.0 · source

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

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);
Run
1.23.0 · source

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);
Run
1.34.0 · source

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

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

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
1.34.0 · source

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

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

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
1.34.0 · source

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

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

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
source§

impl str

字符串切片的方法。

1.20.0 · source

pub fn into_boxed_bytes(self: Box<str, Global>) -> Box<[u8], Global>

无需复制或分配即可将 Box<str> 转换为 Box<[u8]>。

Examples

基本用法：

let s = "this is a string";
let boxed_str = s.to_owned().into_boxed_str();
let boxed_bytes = boxed_str.into_boxed_bytes();
assert_eq!(*boxed_bytes, *s.as_bytes());
Run
source

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

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

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

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

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

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

pub fn to_lowercase(&self) -> String

以新的 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
1.2.0 · source

pub fn to_uppercase(&self) -> String

返回此字符串切片的大写等效项，作为新的 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
1.4.0 · source

pub fn into_string(self: Box<str, Global>) -> String

无需复制或分配即可将 Box<str> 转换为 String。

Examples

基本用法：

let string = String::from("birthday gift");
let boxed_str = string.clone().into_boxed_str();

assert_eq!(boxed_str.into_string(), string);
Run
1.16.0 · source

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

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

Panics

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

Examples

基本用法：

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

溢出时为 panic：

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

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

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

Trait Implementations§

1.14.0 · source§

impl<'a> Add<&'a str> for Cow<'a, str>

§

type Output = Cow<'a, str>

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

fn add(self, rhs: &'a str) -> <Cow<'a, str> as Add<&'a str>>::Output

执行 + 操作。 Read more
source§

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` 已移动，不能再在此处使用。
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
§

type Output = String

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

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

执行 + 操作。 Read more
1.14.0 · source§

impl<'a> AddAssign<&'a str> for Cow<'a, str>

source§

fn add_assign(&mut self, rhs: &'a str)

执行 += 操作。 Read more
1.12.0 · source§

impl AddAssign<&str> for String

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

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

source§

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

执行 += 操作。 Read more
1.43.0 · source§

impl AsMut<str> for String

source§

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

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

impl AsMut<str> for str

source§

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

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

impl AsRef<[u8]> for str

source§

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

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

impl AsRef<OsStr> for str

source§

fn as_ref(&self) -> &OsStr

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

impl AsRef<Path> for str

source§

fn as_ref(&self) -> &Path

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

impl<'a> AsRef<str> for Drain<'a>

source§

fn as_ref(&self) -> &str

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

impl AsRef<str> for String

source§

fn as_ref(&self) -> &str

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

impl AsRef<str> for str

source§

fn as_ref(&self) -> &str

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

impl AsciiExt for str

§

type Owned = String

👎Deprecated since 1.26.0: use inherent methods instead
复制的 ASCII 字符的容器类型。
source§

fn is_ascii(&self) -> bool

👎Deprecated since 1.26.0: use inherent methods instead
检查该值是否在 ASCII 范围内。 Read more
source§

fn to_ascii_uppercase(&self) -> Self::Owned

👎Deprecated since 1.26.0: use inherent methods instead
使值的副本等效于其 ASCII 大写字母。 Read more
source§

fn to_ascii_lowercase(&self) -> Self::Owned

👎Deprecated since 1.26.0: use inherent methods instead
以等效的 ASCII 小写形式复制值。 Read more
source§

fn eq_ignore_ascii_case(&self, o: &Self) -> bool

👎Deprecated since 1.26.0: use inherent methods instead
检查两个值是否为 ASCII 不区分大小写的匹配。 Read more
source§

fn make_ascii_uppercase(&mut self)

👎Deprecated since 1.26.0: use inherent methods instead
将此类型就地转换为其 ASCII 大写等效项。 Read more
source§

fn make_ascii_lowercase(&mut self)

👎Deprecated since 1.26.0: use inherent methods instead
将此类型就地转换为其 ASCII 小写等效项。 Read more
source§

impl Borrow<str> for String

source§

fn borrow(&self) -> &str

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

impl BorrowMut<str> for String

source§

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

从拥有的值中借用。 Read more
1.3.0 · source§

impl Clone for Box<str, Global>

source§

fn clone(&self) -> Box<str, Global>

返回值的副本。 Read more
source§

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

从 source 执行复制分配。 Read more
source§

impl<S> Concat<str> for [S]where S: Borrow<str>,

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

§

type Output = String

🔬This is a nightly-only experimental API. (slice_concat_trait #27747)
串联后的结果类型
source§

fn concat(slice: &[S]) -> String

🔬This is a nightly-only experimental API. (slice_concat_trait #27747)
[T]::concat 的实现
source§

impl Debug for str

source§

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

使用给定的格式化程序格式化该值。 Read more
1.28.0 · source§

impl Default for &mut str

source§

fn default() -> &mut str

创建一个空的可变 str

source§

impl Default for &str

source§

fn default() -> &str

创建一个空的 str

1.17.0 · source§

impl Default for Box<str, Global>

source§

fn default() -> Box<str, Global>

返回类型的 “默认值”。 Read more
source§

impl Display for str

source§

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

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

impl !Error for &str

1.30.0 · source§

fn source(&self) -> Option<&(dyn Error + 'static)>

此错误的下级来源 (如果有)。 Read more
source§

fn description(&self) -> &str

👎Deprecated since 1.42.0: use the Display impl or to_string()
Read more
source§

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0: replaced by Error::source, which can support downcasting
source§

fn provide<'a>(&'a self, demand: &mut Demand<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access #99301)
提供对用于错误报告的上下文的基于类型的访问。 Read more
source§

impl<'a> Extend<&'a str> for String

source§

fn extend<I>(&mut self, iter: I)where I: IntoIterator<Item = &'a str>,

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

fn extend_one(&mut self, s: &'a str)

🔬This is a nightly-only experimental API. (extend_one #72631)
用一个元素扩展一个集合。
source§

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one #72631)
在集合中为给定数量的附加元素保留容量。 Read more
source§

impl<'a> From<&'a str> for Cow<'a, str>

source§

fn from(s: &'a str) -> Cow<'a, str>

将字符串切片转换为 Borrowed 变体。 不执行堆分配，并且不复制字符串。

Example
assert_eq!(Cow::from("eggplant"), Cow::Borrowed("eggplant"));
Run
1.44.0 · source§

impl From<&mut str> for String

source§

fn from(s: &mut str) -> String

将 &mut str 转换为 String。

结果分配在堆上。

1.21.0 · source§

impl From<&str> for Arc<str>

source§

fn from(v: &str) -> Arc<str>

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

Example
let shared: Arc<str> = Arc::from("eggplant");
assert_eq!("eggplant", &shared[..]);
Run
1.6.0 · source§

impl From<&str> for Box<dyn Error + 'static, Global>

source§

fn from(err: &str) -> Box<dyn Error + 'static, Global>

将 str 转换为 dyn Error 的 box。

Examples
use std::error::Error;
use std::mem;

let a_str_error = "a str error";
let a_boxed_error = Box::<dyn Error>::from(a_str_error);
assert!(mem::size_of::<Box<dyn Error>>() == mem::size_of_val(&a_boxed_error))
Run
source§

impl<'a> From<&str> for Box<dyn Error + Send + Sync + 'a, Global>

source§

fn from(err: &str) -> Box<dyn Error + Send + Sync + 'a, Global>

将 str 转换为 Dyn Error + Send + Sync 的 box。

Examples
use std::error::Error;
use std::mem;

let a_str_error = "a str error";
let a_boxed_error = Box::<dyn Error + Send + Sync>::from(a_str_error);
assert!(
    mem::size_of::<Box<dyn Error + Send + Sync>>() == mem::size_of_val(&a_boxed_error))
Run
1.17.0 · source§

impl From<&str> for Box<str, Global>

source§

fn from(s: &str) -> Box<str, Global>

将 &str 转换为 Box<str>

此转换在堆上分配并执行 s 的副本。

Examples
let boxed: Box<str> = Box::from("hello");
println!("{boxed}");
Run
1.21.0 · source§

impl From<&str> for Rc<str>

source§

fn from(v: &str) -> Rc<str>

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

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

impl From<&str> for String

source§

fn from(s: &str) -> String

将 &str 转换为 String。

结果分配在堆上。

source§

impl From<&str> for Vec<u8, Global>

source§

fn from(s: &str) -> Vec<u8, Global> ⓘ

分配一个 Vec<u8> 并用 UTF-8 字符串填充它。

Examples
assert_eq!(Vec::from("123"), vec![b'1', b'2', b'3']);
Run
1.45.0 · source§

impl From<Cow<'_, str>> for Box<str, Global>

source§

fn from(cow: Cow<'_, str>) -> Box<str, Global>

将 Cow<'_, str> 转换为 Box<str>

当 cow 是 Cow::Borrowed 变体时，此转换在堆上分配并复制底层 str。 否则，它将尝试重用拥有所有权的 String 的分配。

Examples
use std::borrow::Cow;

let unboxed = Cow::Borrowed("hello");
let boxed: Box<str> = Box::from(unboxed);
println!("{boxed}");
Run
let unboxed = Cow::Owned("hello".to_string());
let boxed: Box<str> = Box::from(unboxed);
println!("{boxed}");
Run
1.20.0 · source§

impl From<String> for Box<str, Global>

source§

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

impl<'a> FromIterator<&'a str> for String

source§

fn from_iter<I>(iter: I) -> Stringwhere I: IntoIterator<Item = &'a str>,

从迭代器创建一个值。 Read more
1.12.0 · source§

impl<'a, 'b> FromIterator<&'b str> for Cow<'a, str>

source§

fn from_iter<I>(it: I) -> Cow<'a, str>where I: IntoIterator<Item = &'b str>,

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

impl Hash for str

source§

fn hash<H>(&self, state: &mut H)where H: Hasher,

将该值输入给定的 Hasher。 Read more
source§

impl<I> Index<I> for strwhere I: SliceIndex<str>,

§

type Output = <I as SliceIndex<str>>::Output

索引后返回的类型。
source§

fn index(&self, index: I) -> &<I as SliceIndex<str>>::Output

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

impl<I> IndexMut<I> for strwhere I: SliceIndex<str>,

source§

fn index_mut(&mut self, index: I) -> &mut <I as SliceIndex<str>>::Output

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

impl<S> Join<&str> for [S]where S: Borrow<str>,

§

type Output = String

🔬This is a nightly-only experimental API. (slice_concat_trait #27747)
串联后的结果类型
source§

fn join(slice: &[S], sep: &str) -> String

🔬This is a nightly-only experimental API. (slice_concat_trait #27747)
[T]::join 的实现
source§

impl Ord for str

实现字符串排序。

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

source§

fn cmp(&self, other: &str) -> Ordering

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

impl<'a, 'b> PartialEq<&'a str> for String

source§

fn eq(&self, other: &&'a str) -> bool

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

fn ne(&self, other: &&'a str) -> bool

此方法测试 !=。 默认实现几乎总是足够的，并且不应在没有充分理由的情况下被覆盖。
source§

impl<'a, 'b> PartialEq<&'b str> for Cow<'a, str>

source§

fn eq(&self, other: &&'b str) -> bool

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

fn ne(&self, other: &&'b str) -> bool

此方法测试 !=。 默认实现几乎总是足够的，并且不应在没有充分理由的情况下被覆盖。
1.29.0 · source§

impl PartialEq<&str> for OsString

source§

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

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

fn ne(&self, other: &Rhs) -> bool

此方法测试 !=。 默认实现几乎总是足够的，并且不应在没有充分理由的情况下被覆盖。
source§

impl<'a, 'b> PartialEq<Cow<'a, str>> for &'b str

source§

fn eq(&self, other: &Cow<'a, str>) -> bool

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

fn ne(&self, other: &Cow<'a, str>) -> bool

此方法测试 !=。 默认实现几乎总是足够的，并且不应在没有充分理由的情况下被覆盖。
source§

impl<'a, 'b> PartialEq<Cow<'a, str>> for str

source§

fn eq(&self, other: &Cow<'a, str>) -> bool

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

fn ne(&self, other: &Cow<'a, str>) -> bool

此方法测试 !=。 默认实现几乎总是足够的，并且不应在没有充分理由的情况下被覆盖。
source§

impl PartialEq<OsStr> for str

source§

fn eq(&self, other: &OsStr) -> bool

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

fn ne(&self, other: &Rhs) -> bool

此方法测试 !=。 默认实现几乎总是足够的，并且不应在没有充分理由的情况下被覆盖。
1.29.0 · source§

impl<'a> PartialEq<OsString> for &'a str

source§

fn eq(&self, other: &OsString) -> bool

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

fn ne(&self, other: &Rhs) -> bool

此方法测试 !=。 默认实现几乎总是足够的，并且不应在没有充分理由的情况下被覆盖。
source§

impl PartialEq<OsString> for str

source§

fn eq(&self, other: &OsString) -> bool

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

fn ne(&self, other: &Rhs) -> bool

此方法测试 !=。 默认实现几乎总是足够的，并且不应在没有充分理由的情况下被覆盖。
source§

impl<'a, 'b> PartialEq<String> for &'a str

source§

fn eq(&self, other: &String) -> bool

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

fn ne(&self, other: &String) -> bool

此方法测试 !=。 默认实现几乎总是足够的，并且不应在没有充分理由的情况下被覆盖。
source§

impl<'a, 'b> PartialEq<String> for str

source§

fn eq(&self, other: &String) -> bool

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

fn ne(&self, other: &String) -> bool

此方法测试 !=。 默认实现几乎总是足够的，并且不应在没有充分理由的情况下被覆盖。
source§

impl<'a, 'b> PartialEq<str> for Cow<'a, str>

source§

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

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

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

此方法测试 !=。 默认实现几乎总是足够的，并且不应在没有充分理由的情况下被覆盖。
source§

impl PartialEq<str> for OsStr

source§

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

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

fn ne(&self, other: &Rhs) -> bool

此方法测试 !=。 默认实现几乎总是足够的，并且不应在没有充分理由的情况下被覆盖。
source§

impl PartialEq<str> for OsString

source§

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

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

fn ne(&self, other: &Rhs) -> bool

此方法测试 !=。 默认实现几乎总是足够的，并且不应在没有充分理由的情况下被覆盖。
source§

impl<'a, 'b> PartialEq<str> for String

source§

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

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

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

此方法测试 !=。 默认实现几乎总是足够的，并且不应在没有充分理由的情况下被覆盖。
source§

impl PartialEq<str> for str

source§

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

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

fn ne(&self, other: &Rhs) -> bool

此方法测试 !=。 默认实现几乎总是足够的，并且不应在没有充分理由的情况下被覆盖。
source§

impl PartialOrd<str> for OsStr

source§

fn partial_cmp(&self, other: &str) -> Option<Ordering>

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

fn lt(&self, other: &Rhs) -> bool

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

fn le(&self, other: &Rhs) -> bool

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

fn gt(&self, other: &Rhs) -> bool

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

fn ge(&self, other: &Rhs) -> bool

此方法测试是否大于或等于 (对于 self 和 other)，并且由 >= 运算符使用。 Read more
source§

impl PartialOrd<str> for OsString

source§

fn partial_cmp(&self, other: &str) -> Option<Ordering>

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

fn lt(&self, other: &Rhs) -> bool

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

fn le(&self, other: &Rhs) -> bool

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

fn gt(&self, other: &Rhs) -> bool

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

fn ge(&self, other: &Rhs) -> bool

此方法测试是否大于或等于 (对于 self 和 other)，并且由 >= 运算符使用。 Read more
source§

impl PartialOrd<str> for str

对字符串执行比较操作。

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

source§

fn partial_cmp(&self, other: &str) -> Option<Ordering>

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

fn lt(&self, other: &Rhs) -> bool

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

fn le(&self, other: &Rhs) -> bool

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

fn gt(&self, other: &Rhs) -> bool

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

fn ge(&self, other: &Rhs) -> bool

此方法测试是否大于或等于 (对于 self 和 other)，并且由 >= 运算符使用。 Read more
source§

impl<'a, 'b> Pattern<'a> for &'b str

非分配子字符串搜索。

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

Examples

assert_eq!("Hello world".find("world"), Some(6));
Run
source§

fn is_prefix_of(self, haystack: &'a str) -> bool

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

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

source§

fn is_contained_in(self, haystack: &'a str) -> bool

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

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

source§

fn strip_prefix_of(self, haystack: &'a str) -> Option<&'a str>

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

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

source§

fn is_suffix_of(self, haystack: &'a str) -> bool

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

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

source§

fn strip_suffix_of(self, haystack: &'a str) -> Option<&'a str>

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

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

§

type Searcher = StrSearcher<'a, 'b>

🔬This is a nightly-only experimental API. (pattern #27721)
此模式的关联搜索者
source§

fn into_searcher(self, haystack: &'a str) -> StrSearcher<'a, 'b>

🔬This is a nightly-only experimental API. (pattern #27721)
从 self 和 haystack 构造关联的搜索器以进行搜索。
1.20.0 (const: unstable) · source§

impl SliceIndex<str> for Range<usize>

使用语法 &self[begin .. end] 或 &mut self[begin .. end] 实现子字符串切片。

从字节范围 [begin，end`) 返回给定字符串的切片。

此运算为 O(1)。

在 1.20.0 之前，Index 和 IndexMut 的直接实现仍支持这些索引操作。

Panics

如果 begin 或 end 未指向字符的起始字节偏移量 (由 is_char_boundary 定义)，begin > end 或 end > len，就会出现 panics。

Examples

let s = "Löwe 老虎 Léopard";
assert_eq!(&s[0 .. 1], "L");

assert_eq!(&s[1 .. 9], "öwe 老");

// 这些将是 panic：
// 字节 2 位于 `ö` 内：
// &s[2 ..3];

// byte 8 lies within `老` &s[1 ..
// 8];

// 字节 100 在字符串 &s[3 之外。
// 100];
Run
§

type Output = str

方法返回的输出类型。
const: unstable · source§

fn get(self, slice: &str) -> Option<&<Range<usize> as SliceIndex<str>>::Output>

🔬This is a nightly-only experimental API. (slice_index_methods)
如果在边界内，则返回此位置输出的共享引用。
const: unstable · source§

fn get_mut( self, slice: &mut str ) -> Option<&mut <Range<usize> as SliceIndex<str>>::Output>

🔬This is a nightly-only experimental API. (slice_index_methods)
如果在边界内，则对此位置的输出返回一个可变引用。
const: unstable · source§

unsafe fn get_unchecked( self, slice: *const str ) -> *const <Range<usize> as SliceIndex<str>>::Output

🔬This is a nightly-only experimental API. (slice_index_methods)
返回此位置输出的共享引用，而不执行任何边界检查。 即使未使用所得的引用，使用越界索引或悬垂的 slice 指针调用此方法也是 [undefined 行为]。
const: unstable · source§

unsafe fn get_unchecked_mut( self, slice: *mut str ) -> *mut <Range<usize> as SliceIndex<str>>::Output

🔬This is a nightly-only experimental API. (slice_index_methods)
返回此位置输出的变量引用，而不执行任何边界检查。 即使未使用所得的引用，使用越界索引或悬垂的 slice 指针调用此方法也是 [undefined 行为]。
const: unstable · source§

fn index(self, slice: &str) -> &<Range<usize> as SliceIndex<str>>::Output ⓘ

🔬This is a nightly-only experimental API. (slice_index_methods)
返回此位置输出的共享引用，如果越界则会触发 panic。
const: unstable · source§

fn index_mut( self, slice: &mut str ) -> &mut <Range<usize> as SliceIndex<str>>::Output ⓘ

🔬This is a nightly-only experimental API. (slice_index_methods)
返回此位置输出的变量引用，如果越界则会触发 panic。
1.20.0 (const: unstable) · source§

impl SliceIndex<str> for RangeFrom<usize>

使用语法 &self[begin ..] 或 &mut self[begin ..] 实现子字符串切片。

从字节范围 [begin, len) 中返回给定字符串的切片。 相当于 &self[begin .. len] 或 &mut self[begin .. len]。

此运算为 O(1)。

在 1.20.0 之前，Index 和 IndexMut 的直接实现仍支持这些索引操作。

Panics

如果 begin 没有指向字符的起始字节偏移量 (由 is_char_boundary 定义)，或者 begin > len，就会出现 panics。

§

type Output = str

方法返回的输出类型。
const: unstable · source§

fn get( self, slice: &str ) -> Option<&<RangeFrom<usize> as SliceIndex<str>>::Output>

🔬This is a nightly-only experimental API. (slice_index_methods)
如果在边界内，则返回此位置输出的共享引用。
const: unstable · source§

fn get_mut( self, slice: &mut str ) -> Option<&mut <RangeFrom<usize> as SliceIndex<str>>::Output>

🔬This is a nightly-only experimental API. (slice_index_methods)
如果在边界内，则对此位置的输出返回一个可变引用。
const: unstable · source§

unsafe fn get_unchecked( self, slice: *const str ) -> *const <RangeFrom<usize> as SliceIndex<str>>::Output

🔬This is a nightly-only experimental API. (slice_index_methods)
返回此位置输出的共享引用，而不执行任何边界检查。 即使未使用所得的引用，使用越界索引或悬垂的 slice 指针调用此方法也是 [undefined 行为]。
const: unstable · source§

unsafe fn get_unchecked_mut( self, slice: *mut str ) -> *mut <RangeFrom<usize> as SliceIndex<str>>::Output

🔬This is a nightly-only experimental API. (slice_index_methods)
返回此位置输出的变量引用，而不执行任何边界检查。 即使未使用所得的引用，使用越界索引或悬垂的 slice 指针调用此方法也是 [undefined 行为]。
const: unstable · source§

fn index(self, slice: &str) -> &<RangeFrom<usize> as SliceIndex<str>>::Output ⓘ

🔬This is a nightly-only experimental API. (slice_index_methods)
返回此位置输出的共享引用，如果越界则会触发 panic。
const: unstable · source§

fn index_mut( self, slice: &mut str ) -> &mut <RangeFrom<usize> as SliceIndex<str>>::Output ⓘ

🔬This is a nightly-only experimental API. (slice_index_methods)
返回此位置输出的变量引用，如果越界则会触发 panic。
1.20.0 (const: unstable) · source§

impl SliceIndex<str> for RangeFull

使用语法 &self[..] 或 &mut self[..] 实现子字符串切片。

返回整个字符串的切片，即返回 &self 或 &mut self。相当于 &self[0 .. len] 或 &mut self[0 .. len]. 与其他索引操作不同，此操作永远不能 panic。

此运算为 O(1)。

在 1.20.0 之前，Index 和 IndexMut 的直接实现仍支持这些索引操作。

等效于 &self[0 .. len] 或 &mut self[0 .. len]。

§

type Output = str

方法返回的输出类型。
const: unstable · source§

fn get(self, slice: &str) -> Option<&<RangeFull as SliceIndex<str>>::Output>

🔬This is a nightly-only experimental API. (slice_index_methods)
如果在边界内，则返回此位置输出的共享引用。
const: unstable · source§

fn get_mut( self, slice: &mut str ) -> Option<&mut <RangeFull as SliceIndex<str>>::Output>

🔬This is a nightly-only experimental API. (slice_index_methods)
如果在边界内，则对此位置的输出返回一个可变引用。
const: unstable · source§

unsafe fn get_unchecked( self, slice: *const str ) -> *const <RangeFull as SliceIndex<str>>::Output

🔬This is a nightly-only experimental API. (slice_index_methods)
返回此位置输出的共享引用，而不执行任何边界检查。 即使未使用所得的引用，使用越界索引或悬垂的 slice 指针调用此方法也是 [undefined 行为]。
const: unstable · source§

unsafe fn get_unchecked_mut( self, slice: *mut str ) -> *mut <RangeFull as SliceIndex<str>>::Output

🔬This is a nightly-only experimental API. (slice_index_methods)
返回此位置输出的变量引用，而不执行任何边界检查。 即使未使用所得的引用，使用越界索引或悬垂的 slice 指针调用此方法也是 [undefined 行为]。
const: unstable · source§

fn index(self, slice: &str) -> &<RangeFull as SliceIndex<str>>::Output

🔬This is a nightly-only experimental API. (slice_index_methods)
返回此位置输出的共享引用，如果越界则会触发 panic。
const: unstable · source§

fn index_mut( self, slice: &mut str ) -> &mut <RangeFull as SliceIndex<str>>::Output

🔬This is a nightly-only experimental API. (slice_index_methods)
返回此位置输出的变量引用，如果越界则会触发 panic。
1.26.0 (const: unstable) · source§

impl SliceIndex<str> for RangeInclusive<usize>

使用语法 &self[begin ..= end] 或 &mut self[begin ..= end] 实现子字符串切片。

从字节范围 [begin, end] 返回给定字符串的切片。等效于 &self [begin .. end + 1] 或 &mut self[begin .. end + 1]，除非 end 具有 usize 的最大值。

此运算为 O(1)。

Panics

如果 begin 没有指向字符的起始字节偏移量 (由 is_char_boundary 定义)，如果 end 没有指向字符的结束字节偏移量 (end + 1 是起始字节偏移量或等于 len)，如果 begin > end，或者如果 end >= len，就会出现 panics。

§

type Output = str

方法返回的输出类型。
const: unstable · source§

fn get( self, slice: &str ) -> Option<&<RangeInclusive<usize> as SliceIndex<str>>::Output>

🔬This is a nightly-only experimental API. (slice_index_methods)
如果在边界内，则返回此位置输出的共享引用。
const: unstable · source§

fn get_mut( self, slice: &mut str ) -> Option<&mut <RangeInclusive<usize> as SliceIndex<str>>::Output>

🔬This is a nightly-only experimental API. (slice_index_methods)
如果在边界内，则对此位置的输出返回一个可变引用。
const: unstable · source§

unsafe fn get_unchecked( self, slice: *const str ) -> *const <RangeInclusive<usize> as SliceIndex<str>>::Output

🔬This is a nightly-only experimental API. (slice_index_methods)
返回此位置输出的共享引用，而不执行任何边界检查。 即使未使用所得的引用，使用越界索引或悬垂的 slice 指针调用此方法也是 [undefined 行为]。
const: unstable · source§

unsafe fn get_unchecked_mut( self, slice: *mut str ) -> *mut <RangeInclusive<usize> as SliceIndex<str>>::Output

🔬This is a nightly-only experimental API. (slice_index_methods)
返回此位置输出的变量引用，而不执行任何边界检查。 即使未使用所得的引用，使用越界索引或悬垂的 slice 指针调用此方法也是 [undefined 行为]。
const: unstable · source§

fn index( self, slice: &str ) -> &<RangeInclusive<usize> as SliceIndex<str>>::Output ⓘ

🔬This is a nightly-only experimental API. (slice_index_methods)
返回此位置输出的共享引用，如果越界则会触发 panic。
const: unstable · source§

fn index_mut( self, slice: &mut str ) -> &mut <RangeInclusive<usize> as SliceIndex<str>>::Output ⓘ

🔬This is a nightly-only experimental API. (slice_index_methods)
返回此位置输出的变量引用，如果越界则会触发 panic。
1.20.0 (const: unstable) · source§

impl SliceIndex<str> for RangeTo<usize>

使用语法 &self[.. end] 或 &mut self[.. end] 实现子字符串切片。

从字节范围 [0, end) 中返回给定字符串的切片。 等效于 &self[0 .. end] 或 &mut self[0 .. end]。

此运算为 O(1)。

在 1.20.0 之前，Index 和 IndexMut 的直接实现仍支持这些索引操作。

Panics

如果 end 没有指向字符的起始字节偏移量 (由 is_char_boundary 定义)，或者 end > len，就会出现 panics。

§

type Output = str

方法返回的输出类型。
const: unstable · source§

fn get( self, slice: &str ) -> Option<&<RangeTo<usize> as SliceIndex<str>>::Output>

🔬This is a nightly-only experimental API. (slice_index_methods)
如果在边界内，则返回此位置输出的共享引用。
const: unstable · source§

fn get_mut( self, slice: &mut str ) -> Option<&mut <RangeTo<usize> as SliceIndex<str>>::Output>

🔬This is a nightly-only experimental API. (slice_index_methods)
如果在边界内，则对此位置的输出返回一个可变引用。
const: unstable · source§

unsafe fn get_unchecked( self, slice: *const str ) -> *const <RangeTo<usize> as SliceIndex<str>>::Output

🔬This is a nightly-only experimental API. (slice_index_methods)
返回此位置输出的共享引用，而不执行任何边界检查。 即使未使用所得的引用，使用越界索引或悬垂的 slice 指针调用此方法也是 [undefined 行为]。
const: unstable · source§

unsafe fn get_unchecked_mut( self, slice: *mut str ) -> *mut <RangeTo<usize> as SliceIndex<str>>::Output

🔬This is a nightly-only experimental API. (slice_index_methods)
返回此位置输出的变量引用，而不执行任何边界检查。 即使未使用所得的引用，使用越界索引或悬垂的 slice 指针调用此方法也是 [undefined 行为]。
const: unstable · source§

fn index(self, slice: &str) -> &<RangeTo<usize> as SliceIndex<str>>::Output

🔬This is a nightly-only experimental API. (slice_index_methods)
返回此位置输出的共享引用，如果越界则会触发 panic。
const: unstable · source§

fn index_mut( self, slice: &mut str ) -> &mut <RangeTo<usize> as SliceIndex<str>>::Output

🔬This is a nightly-only experimental API. (slice_index_methods)
返回此位置输出的变量引用，如果越界则会触发 panic。
1.26.0 (const: unstable) · source§

impl SliceIndex<str> for RangeToInclusive<usize>

使用语法 &self[..= end] 或 &mut self[..= end] 实现子字符串切片。

从字节范围 [0, end] 中返回给定字符串的切片。 等效于 &self [0 .. end + 1]，除非 end 具有 usize 的最大值。

此运算为 O(1)。

Panics

如果 end 没有指向字符的结束字节偏移量 (end + 1 是 is_char_boundary 定义的起始字节偏移量，或者等于 len)，或者如果 end >= len，就会出现 panics。

§

type Output = str

方法返回的输出类型。
const: unstable · source§

fn get( self, slice: &str ) -> Option<&<RangeToInclusive<usize> as SliceIndex<str>>::Output>

🔬This is a nightly-only experimental API. (slice_index_methods)
如果在边界内，则返回此位置输出的共享引用。
const: unstable · source§

fn get_mut( self, slice: &mut str ) -> Option<&mut <RangeToInclusive<usize> as SliceIndex<str>>::Output>

🔬This is a nightly-only experimental API. (slice_index_methods)
如果在边界内，则对此位置的输出返回一个可变引用。
const: unstable · source§

unsafe fn get_unchecked( self, slice: *const str ) -> *const <RangeToInclusive<usize> as SliceIndex<str>>::Output

🔬This is a nightly-only experimental API. (slice_index_methods)
返回此位置输出的共享引用，而不执行任何边界检查。 即使未使用所得的引用，使用越界索引或悬垂的 slice 指针调用此方法也是 [undefined 行为]。
const: unstable · source§

unsafe fn get_unchecked_mut( self, slice: *mut str ) -> *mut <RangeToInclusive<usize> as SliceIndex<str>>::Output

🔬This is a nightly-only experimental API. (slice_index_methods)
返回此位置输出的变量引用，而不执行任何边界检查。 即使未使用所得的引用，使用越界索引或悬垂的 slice 指针调用此方法也是 [undefined 行为]。
const: unstable · source§

fn index( self, slice: &str ) -> &<RangeToInclusive<usize> as SliceIndex<str>>::Output

🔬This is a nightly-only experimental API. (slice_index_methods)
返回此位置输出的共享引用，如果越界则会触发 panic。
const: unstable · source§

fn index_mut( self, slice: &mut str ) -> &mut <RangeToInclusive<usize> as SliceIndex<str>>::Output

🔬This is a nightly-only experimental API. (slice_index_methods)
返回此位置输出的变量引用，如果越界则会触发 panic。
source§

impl ToOwned for str

§

type Owned = String

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

fn to_owned(&self) -> String

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

fn clone_into(&self, target: &mut String)

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

impl ToSocketAddrs for str

§

type Iter = IntoIter<SocketAddr, Global>

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

fn to_socket_addrs(&self) -> Result<IntoIter<SocketAddr>>

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

impl ToString for str

source§

fn to_string(&self) -> String

将给定值转换为 String。 Read more
source§

impl ConstParamTy for str

source§

impl Eq for str

source§

impl StructuralEq for str

Auto Trait Implementations§

§

impl RefUnwindSafe for str

§

impl Send for str

§

impl !Sized for str

§

impl Sync for str

§

impl Unpin for str

§

impl UnwindSafe for str

Blanket Implementations§

source§

impl<T> Any for Twhere T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

获取 self 的 TypeId。 Read more
source§

impl<T> Borrow<T> for Twhere T: ?Sized,

source§

fn borrow(&self) -> &T

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

impl<T> BorrowMut<T> for Twhere T: ?Sized,

source§

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

从拥有的值中借用。 Read more
source§

impl<T> ToString for Twhere T: Display + ?Sized,

source§

default fn to_string(&self) -> String

将给定值转换为 String。 Read more