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_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

[src]

impl str

1.0.0 (const: 1.39.0)[src]

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

1.0.0 (const: 1.39.0)[src]

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[src]

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

1.0.0 (const: 1.39.0)[src]

pub const fn as_bytes(&self) -> &[u8 ]ⓘ
Notable traits for &[u8 ]
`impl Read for &[u8]impl Write for &mut [u8]`

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

Examples

基本用法：

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

Run

1.20.0[src]

pub unsafe fn as_bytes_mut(&mut self) -> &mut [u8 ]ⓘ
Notable traits for &[u8 ]
`impl Read for &[u8]impl Write for &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

1.0.0 (const: 1.32.0)[src]

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[src]

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

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

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

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

1.20.0[src]

pub fn get(&self, i: I) -> Option<&>::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[src]

pub fn get_mut(
 &mut self,
 i: I
) -> Option<&mut >::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[src]

pub unsafe fn get_unchecked(&self, i: I) -> &>::Output where
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[src]

pub unsafe fn get_unchecked_mut(
 &mut self,
 i: I
) -> &mut >::Output where
 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

[src]

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[src]

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[src]

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[src]

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

[src]

pub fn chars(&self) -> Chars<'_>ⓘ
Notable traits for Chars<'a>
`impl<'a> Iterator for Chars<'a> type Item = char;`

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

[src]

pub fn char_indices(&self) -> CharIndices<'_>ⓘ
Notable traits for CharIndices<'a>
`impl<'a> Iterator for CharIndices<'a> type Item = (usize, char);`

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

[src]

pub fn bytes(&self) -> Bytes<'_>ⓘ
Notable traits for Bytes<'_>
`impl<'_> Iterator for Bytes<'_> type Item = u8;`

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

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

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[src]

pub fn split_whitespace(&self) -> SplitWhitespace<'_>ⓘ
Notable traits for SplitWhitespace<'a>
`impl<'a> Iterator for SplitWhitespace<'a> type Item = &'a str;`

用空格分割字符串切片。

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

‘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

1.34.0[src]

pub fn split_ascii_whitespace(&self) -> SplitAsciiWhitespace<'_>ⓘ
Notable traits for SplitAsciiWhitespace<'a>
`impl<'a> Iterator for SplitAsciiWhitespace<'a> type Item = &'a str;`

用 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

[src]

pub fn lines(&self) -> Lines<'_>ⓘ
Notable traits for Lines<'a>
`impl<'a> Iterator for Lines<'a> type Item = &'a str;`

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

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

[src]

pub fn lines_any(&self) -> LinesAny<'_>ⓘ
Notable traits for LinesAny<'a>
`impl<'a> Iterator for LinesAny<'a> type Item = &'a str;`

👎 Deprecated since 1.4.0:

use lines() instead now

字符串行上的迭代器。

1.8.0[src]

pub fn encode_utf16(&self) -> EncodeUtf16<'_>ⓘ
Notable traits for EncodeUtf16<'a>
`impl<'a> Iterator for EncodeUtf16<'a> type Item = u16;`

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

[src]

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

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

如果不是，则返回 false。

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

Examples

基本用法：

let bananas = "bananas";

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

Run

[src]

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

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

如果不是，则返回 false。

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

Examples

基本用法：

let bananas = "bananas";

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

Run

[src]

pub fn ends_with<'a, P>(&'a self, pat: P) -> bool where
P: 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

[src]

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

[src]

pub fn rfind<'a, P>(&'a self, pat: P) -> Option<usize> where
P: 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

[src]

pub fn split<'a, P>(&'a self, pat: P) -> Split<'a, P>ⓘ
Notable traits for Split<'a, P>
`impl<'a, P> Iterator for Split<'a, P> where P: Pattern<'a>, type Item = &'a str;`
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[src]

pub fn split_inclusive<'a, P>(&'a self, pat: P) -> SplitInclusive<'a, P>ⓘ
Notable traits for SplitInclusive<'a, P>
`impl<'a, P> Iterator for SplitInclusive<'a, P> where P: Pattern<'a>, type Item = &'a str;`
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

[src]

pub fn rsplit<'a, P>(&'a self, pat: P) -> RSplit<'a, P>ⓘ
Notable traits for RSplit<'a, P>
`impl<'a, P> Iterator for RSplit<'a, P> where P: Pattern<'a>, >::Searcher: ReverseSearcher<'a>, type Item = &'a str;`
where
 P: 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

[src]

pub fn split_terminator<'a, P>(&'a self, pat: P) -> SplitTerminator<'a, P>ⓘ
Notable traits for SplitTerminator<'a, P>
`impl<'a, P> Iterator for SplitTerminator<'a, P> where P: Pattern<'a>, type Item = &'a str;`
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

[src]

pub fn rsplit_terminator<'a, P>(&'a self, pat: P) -> RSplitTerminator<'a, P>ⓘ
Notable traits for RSplitTerminator<'a, P>
`impl<'a, P> Iterator for RSplitTerminator<'a, P> where P: Pattern<'a>, >::Searcher: ReverseSearcher<'a>, type Item = &'a str;`
where
 P: 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

[src]

pub fn splitn<'a, P>(&'a self, n: usize, pat: P) -> SplitN<'a, P>ⓘ
Notable traits for SplitN<'a, P>
`impl<'a, P> Iterator for SplitN<'a, P> where P: Pattern<'a>, type Item = &'a str;`
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

[src]

pub fn rsplitn<'a, P>(&'a self, n: usize, pat: P) -> RSplitN<'a, P>ⓘ
Notable traits for RSplitN<'a, P>
`impl<'a, P> Iterator for RSplitN<'a, P> where P: Pattern<'a>, >::Searcher: ReverseSearcher<'a>, type Item = &'a str;`
where
 P: 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[src]

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=foo".split_once('='), Some(("cfg", "foo")));
assert_eq!("cfg=foo=bar".split_once('='), Some(("cfg", "foo=bar")));

Run

1.52.0[src]

pub fn rsplit_once<'a, P>(&'a self, delimiter: P) -> Option<(&'a str, &'a str )> where
P: 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[src]

pub fn matches<'a, P>(&'a self, pat: P) -> Matches<'a, P>ⓘ
Notable traits for Matches<'a, P>
`impl<'a, P> Iterator for Matches<'a, P> where P: Pattern<'a>, type Item = &'a str;`
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[src]

pub fn rmatches<'a, P>(&'a self, pat: P) -> RMatches<'a, P>ⓘ
Notable traits for RMatches<'a, P>
`impl<'a, P> Iterator for RMatches<'a, P> where P: Pattern<'a>, >::Searcher: ReverseSearcher<'a>, type Item = &'a str;`
where
 P: 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[src]

pub fn match_indices<'a, P>(&'a self, pat: P) -> MatchIndices<'a, P>ⓘ
Notable traits for MatchIndices<'a, P>
`impl<'a, P> Iterator for MatchIndices<'a, P> where P: Pattern<'a>, type Item = (usize, &'a str);`
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[src]

pub fn rmatch_indices<'a, P>(&'a self, pat: P) -> RMatchIndices<'a, P>ⓘ
Notable traits for RMatchIndices<'a, P>
`impl<'a, P> Iterator for RMatchIndices<'a, P> where P: Pattern<'a>, >::Searcher: ReverseSearcher<'a>, type Item = (usize, &'a str);`
where
 P: 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

[src]

pub fn trim(&self) -> &str

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

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

Examples

基本用法：

let s = " Hello\tworld\t";

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

Run

1.30.0[src]

pub fn trim_start(&self) -> &str

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

‘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

1.30.0[src]

pub fn trim_end(&self) -> &str

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

‘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

[src]

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

[src]

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

[src]

pub fn trim_matches<'a, P>(&'a self, pat: P) -> &'a str where
P: 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[src]

pub fn trim_start_matches<'a, P>(&'a self, pat: P) -> &'a str where
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[src]

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[src]

pub fn strip_suffix<'a, P>(&'a self, suffix: P) -> Option<&'a str> where
P: 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[src]

pub fn trim_end_matches<'a, P>(&'a self, pat: P) -> &'a str where
P: 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

[src]

pub fn trim_left_matches<'a, P>(&'a self, pat: P) -> &'a str where
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

[src]

pub fn trim_right_matches<'a, P>(&'a self, pat: P) -> &'a str where
P: 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

[src]

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[src]

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

1.23.0[src]

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[src]

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[src]

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[src]

pub fn escape_debug(&self) -> EscapeDebug<'_>ⓘ
Notable traits for EscapeDebug<'a>
`impl<'a> Iterator for EscapeDebug<'a> type Item = char;`

返回一个迭代器，该迭代器使用 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[src]

pub fn escape_default(&self) -> EscapeDefault<'_>ⓘ
Notable traits for EscapeDefault<'a>
`impl<'a> Iterator for EscapeDefault<'a> type Item = char;`

返回一个迭代器，该迭代器使用 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[src]

pub fn escape_unicode(&self) -> EscapeUnicode<'_>ⓘ
Notable traits for EscapeUnicode<'a>
`impl<'a> Iterator for EscapeUnicode<'a> type Item = char;`

返回一个迭代器，该迭代器使用 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

[src]

impl str

字符串切片的方法。

1.20.0[src]

pub fn into_boxed_bytes(self: Box<str, Global>) -> Box<[u8 ], Global>ⓘ
Notable traits for Box<I, A>
`impl<I, A> Iterator for Box<I, A> where I: Iterator + ?Sized, A: Allocator, type Item = ::Item;impl<F, A> Future for Box<F, A> where F: Future + Unpin + ?Sized, A: Allocator + 'static, type Output = <F as Future>::Output;impl<R: Read + ?Sized> Read for Box<R>impl<W: Write + ?Sized> Write for Box<W>`

无需复制或分配即可将 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

[src]

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

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

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

Examples

基本用法：

let s = "this is old";

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

Run

当模式不匹配时：

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

Run

1.16.0[src]

pub fn replacen<'a, P>(&'a self, pat: P, to: &str, count: usize) -> String where
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

当模式不匹配时：

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

Run

1.2.0[src]

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[src]

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[src]

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[src]

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[src]

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[src]

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

[src]

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

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

[src]

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

执行 + 操作。 Read more

1.14.0[src]

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

type Output = Cow<'a, str>

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

[src]

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

执行 + 操作。 Read more

1.12.0[src]

impl<'_> AddAssign<&'_ str> for String

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

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

[src]

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

执行 += 操作。 Read more

1.14.0[src]

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

[src]

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

执行 += 操作。 Read more

1.51.0[src]

impl AsMut<str> for str

[src]

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

执行转换。

1.43.0[src]

impl AsMut<str> for String

[src]

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

执行转换。

[src]

impl AsRef<[u8 ]> for str

[src]

pub fn as_ref(&self) -> &[u8 ]ⓘ
Notable traits for &[u8 ]
`impl Read for &[u8]impl Write for &mut [u8]`

执行转换。

[src]

impl AsRef<OsStr> for str

[src]

fn as_ref(&self) -> &OsStr

执行转换。

[src]

impl AsRef<Path> for str

[src]

fn as_ref(&self) -> &Path

执行转换。

[src]

impl AsRef<str> for str

[src]

pub fn as_ref(&self) -> &str

执行转换。

[src]

impl AsRef<str> for String

[src]

pub fn as_ref(&self) -> &str

执行转换。

1.55.0[src]

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

[src]

pub fn as_ref(&self) -> &str

执行转换。

[src]

impl AsciiExt for str

type Owned = String

👎 Deprecated since 1.26.0:

use inherent methods instead

复制的 ASCII 字符的容器类型。

[src]

fn is_ascii(&self) -> bool

👎 Deprecated since 1.26.0:

use inherent methods instead

检查该值是否在 ASCII 范围内。 Read more

[src]

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

👎 Deprecated since 1.26.0:

use inherent methods instead

使值的副本等效于其 ASCII 大写字母。 Read more

[src]

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

👎 Deprecated since 1.26.0:

use inherent methods instead

以等效的 ASCII 小写形式复制值。 Read more

[src]

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

👎 Deprecated since 1.26.0:

use inherent methods instead

检查两个值是否为 ASCII 不区分大小写的匹配。 Read more

[src]

fn make_ascii_uppercase(&mut self)

👎 Deprecated since 1.26.0:

use inherent methods instead

将此类型就地转换为其 ASCII 大写等效项。 Read more

[src]

fn make_ascii_lowercase(&mut self)

👎 Deprecated since 1.26.0:

use inherent methods instead

将此类型就地转换为其 ASCII 小写等效项。 Read more

[src]

impl Borrow<str> for String

[src]

pub fn borrow(&self) -> &str

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

1.36.0[src]

impl BorrowMut<str> for String

[src]

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

从拥有的值中借用。 Read more

[src]

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)

串联后的结果类型

[src]

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

🔬 This is a nightly-only experimental API. (slice_concat_trait #27747)

[T]::concat 的实现

[src]

impl Debug for str

[src]

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

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

1.0.0 (const: unstable)[src]

impl<'_> Default for &'_ str

[src]

pub fn default() -> &'_ str

创建一个空的 str

1.28.0[src]

impl<'_> Default for &'_ mut str

[src]

pub fn default() -> &'_ mut str

创建一个空的可变 str

[src]

impl Display for str

[src]

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

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

[src]

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

[src]

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

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

[src]

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

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

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

[src]

fn extend_reserve(&mut self, additional: usize)

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

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

1.44.0[src]

impl<'_> From<&'_ mut str> for String

[src]

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

将 &mut str 转换为 String。

结果分配在堆上。

1.21.0[src]

impl<'_> From<&'_ str> for Rc<str>

[src]

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

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

Example

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

Run

[src]

impl<'_> From<&'_ str> for String

[src]

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

将 &str 转换为 String。

结果分配在堆上。

[src]

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

[src]

pub fn from(s: &str) -> Vec<u8, Global>ⓘ
Notable traits for Vec<u8, A>
`impl<A: Allocator> Write for Vec<u8, A>`

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

Examples

assert_eq!(Vec::from("123"), vec![b'1', b'2', b'3']);

Run

1.21.0[src]

impl<'_> From<&'_ str> for Arc<str>

[src]

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

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

Example

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

Run

1.17.0[src]

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

[src]

pub fn from(s: &str) -> Box<str, Global>ⓘ
Notable traits for Box<I, A>
`impl<I, A> Iterator for Box<I, A> where I: Iterator + ?Sized, A: Allocator, type Item = ::Item;impl<F, A> Future for Box<F, A> where F: Future + Unpin + ?Sized, A: Allocator + 'static, type Output = <F as Future>::Output;impl<R: Read + ?Sized> Read for Box<R>impl<W: Write + ?Sized> Write for Box<W>`

将 &str 转换为 Box<str>

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

Examples

let boxed: Box<str> = Box::from("hello");
println!("{}", boxed);

Run

[src]

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

[src]

fn from(err: &str) -> Box<dyn Error + Send + Sync + 'a>ⓘ
Notable traits for Box<I, A>
`impl<I, A> Iterator for Box<I, A> where I: Iterator + ?Sized, A: Allocator, type Item = ::Item;impl<F, A> Future for Box<F, A> where F: Future + Unpin + ?Sized, A: Allocator + 'static, type Output = <F as Future>::Output;impl<R: Read + ?Sized> Read for Box<R>impl<W: Write + ?Sized> Write for Box<W>`

将 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.6.0[src]

impl From<&'_ str> for Box<dyn Error>

[src]

fn from(err: &str) -> Box<dyn Error>ⓘ
Notable traits for Box<I, A>
`impl<I, A> Iterator for Box<I, A> where I: Iterator + ?Sized, A: Allocator, type Item = ::Item;impl<F, A> Future for Box<F, A> where F: Future + Unpin + ?Sized, A: Allocator + 'static, type Output = <F as Future>::Output;impl<R: Read + ?Sized> Read for Box<R>impl<W: Write + ?Sized> Write for Box<W>`

将 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

[src]

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

[src]

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

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

Example

assert_eq!(Cow::from("eggplant"), Cow::Borrowed("eggplant"));

Run

[src]

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

[src]

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

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

1.12.0[src]

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

[src]

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

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

[src]

impl Hash for str

[src]

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

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

1.3.0[src]

fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,

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

[src]

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

type Output = >::Output

索引后返回的类型。

[src]

pub fn index(&self, index: I) -> &>::Output

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

[src]

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

[src]

pub fn index_mut(&mut self, index: I) -> &mut >::Output

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

[src]

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

type Output = String

🔬 This is a nightly-only experimental API. (slice_concat_trait #27747)

串联后的结果类型

[src]

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

🔬 This is a nightly-only experimental API. (slice_concat_trait #27747)

[T]::join 的实现

[src]

impl Ord for str

实现字符串排序。

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

[src]

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

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

1.21.0[src]

fn max(self, other: Self) -> Self

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

1.21.0[src]

fn min(self, other: Self) -> Self

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

1.50.0[src]

fn clamp(self, min: Self, max: Self) -> Self

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

1.29.0[src]

impl PartialEq<&'_ str> for OsString

[src]

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

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

[src]

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

此方法测试 !=。

[src]

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

[src]

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

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

[src]

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

此方法测试 !=。

[src]

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

[src]

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

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

[src]

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

此方法测试 !=。

[src]

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

[src]

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

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

[src]

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

此方法测试 !=。

[src]

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

[src]

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

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

[src]

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

此方法测试 !=。

[src]

impl PartialEq<OsStr> for str

[src]

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

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

[src]

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

此方法测试 !=。

[src]

impl PartialEq<OsString> for str

[src]

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

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

[src]

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

此方法测试 !=。

1.29.0[src]

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

[src]

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

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

[src]

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

此方法测试 !=。

[src]

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

[src]

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

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

[src]

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

此方法测试 !=。

[src]

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

[src]

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

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

[src]

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

此方法测试 !=。

[src]

impl PartialEq<str> for str

[src]

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

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

[src]

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

此方法测试 !=。

[src]

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

[src]

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

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

[src]

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

此方法测试 !=。

[src]

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

[src]

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

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

[src]

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

此方法测试 !=。

[src]

impl PartialEq<str> for OsString

[src]

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

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

[src]

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

此方法测试 !=。

[src]

impl PartialEq<str> for OsStr

[src]

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

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

[src]

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

此方法测试 !=。

[src]

impl PartialOrd<str> for str

对字符串执行比较操作。

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

[src]

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

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

[src]

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

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

[src]

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

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

[src]

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

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

[src]

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

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

[src]

impl PartialOrd<str> for OsString

[src]

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

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

[src]

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

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

[src]

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

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

[src]

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

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

[src]

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

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

[src]

impl PartialOrd<str> for OsStr

[src]

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

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

[src]

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

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

[src]

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

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

[src]

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

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

[src]

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

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

[src]

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

非分配子字符串搜索。

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

Examples

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

Run

[src]

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

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

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

[src]

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

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

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

[src]

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

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

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

[src]

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

此模式的关联搜索者

[src]

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

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

从 self 和 haystack 构造关联的搜索器以进行搜索。 Read more

[src]

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

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

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

1.20.0[src]

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

方法返回的输出类型。

[src]

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

🔬 This is a nightly-only experimental API. (slice_index_methods)

如果在边界内，则返回此位置输出的共享引用。 Read more

[src]

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

如果在边界内，则对此位置的输出返回一个可变引用。 Read more

[src]

pub 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 行为]。 Read more

[src]

pub 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 行为]。 Read more

[src]

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

🔬 This is a nightly-only experimental API. (slice_index_methods)

返回此位置输出的共享引用，如果越界则会触发 panic。 Read more

[src]

pub 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。 Read more

1.20.0[src]

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

方法返回的输出类型。

[src]

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

🔬 This is a nightly-only experimental API. (slice_index_methods)

如果在边界内，则返回此位置输出的共享引用。 Read more

[src]

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

如果在边界内，则对此位置的输出返回一个可变引用。 Read more

[src]

pub 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 行为]。 Read more

[src]

pub 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 行为]。 Read more

[src]

pub fn index(
 self,
 slice: &str
) -> &<RangeFrom<usize> as SliceIndex<str>>::Outputⓘ
Notable traits for RangeFrom<A>
`impl<A> Iterator for RangeFrom<A> where A: Step, type Item = A;`

🔬 This is a nightly-only experimental API. (slice_index_methods)

返回此位置输出的共享引用，如果越界则会触发 panic。 Read more

[src]

pub fn index_mut(
 self,
 slice: &mut str
) -> &mut <RangeFrom<usize> as SliceIndex<str>>::Outputⓘ
Notable traits for RangeFrom<A>
`impl<A> Iterator for RangeFrom<A> where A: Step, type Item = A;`

🔬 This is a nightly-only experimental API. (slice_index_methods)

返回此位置输出的变量引用，如果越界则会触发 panic。 Read more

1.20.0[src]

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

方法返回的输出类型。

[src]

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

🔬 This is a nightly-only experimental API. (slice_index_methods)

如果在边界内，则返回此位置输出的共享引用。 Read more

[src]

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

如果在边界内，则对此位置的输出返回一个可变引用。 Read more

[src]

pub 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 行为]。 Read more

[src]

pub 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 行为]。 Read more

[src]

pub fn index(self, slice: &str) -> &<Range<usize> as SliceIndex<str>>::Outputⓘ
Notable traits for Range<A>
`impl<A> Iterator for Range<A> where A: Step, type Item = A;`

🔬 This is a nightly-only experimental API. (slice_index_methods)

返回此位置输出的共享引用，如果越界则会触发 panic。 Read more

[src]

pub fn index_mut(
 self,
 slice: &mut str
) -> &mut <Range<usize> as SliceIndex<str>>::Outputⓘ
Notable traits for Range<A>
`impl<A> Iterator for Range<A> where A: Step, type Item = A;`

🔬 This is a nightly-only experimental API. (slice_index_methods)

返回此位置输出的变量引用，如果越界则会触发 panic。 Read more

1.26.0[src]

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

方法返回的输出类型。

[src]

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

🔬 This is a nightly-only experimental API. (slice_index_methods)

如果在边界内，则返回此位置输出的共享引用。 Read more

[src]

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

如果在边界内，则对此位置的输出返回一个可变引用。 Read more

[src]

pub 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 行为]。 Read more

[src]

pub 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 行为]。 Read more

[src]

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

🔬 This is a nightly-only experimental API. (slice_index_methods)

返回此位置输出的共享引用，如果越界则会触发 panic。 Read more

[src]

pub 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。 Read more

1.26.0[src]

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

方法返回的输出类型。

[src]

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

🔬 This is a nightly-only experimental API. (slice_index_methods)

如果在边界内，则返回此位置输出的共享引用。 Read more

[src]

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

如果在边界内，则对此位置的输出返回一个可变引用。 Read more

[src]

pub 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 行为]。 Read more

[src]

pub 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 行为]。 Read more

[src]

pub fn index(
 self,
 slice: &str
) -> &<RangeInclusive<usize> as SliceIndex<str>>::Outputⓘ
Notable traits for RangeInclusive<A>
`impl<A> Iterator for RangeInclusive<A> where A: Step, type Item = A;`

🔬 This is a nightly-only experimental API. (slice_index_methods)

返回此位置输出的共享引用，如果越界则会触发 panic。 Read more

[src]

pub fn index_mut(
 self,
 slice: &mut str
) -> &mut <RangeInclusive<usize> as SliceIndex<str>>::Outputⓘ
Notable traits for RangeInclusive<A>
`impl<A> Iterator for RangeInclusive<A> where A: Step, type Item = A;`

🔬 This is a nightly-only experimental API. (slice_index_methods)

返回此位置输出的变量引用，如果越界则会触发 panic。 Read more

1.20.0[src]

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

方法返回的输出类型。

[src]

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

🔬 This is a nightly-only experimental API. (slice_index_methods)

如果在边界内，则返回此位置输出的共享引用。 Read more

[src]

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

🔬 This is a nightly-only experimental API. (slice_index_methods)

如果在边界内，则对此位置的输出返回一个可变引用。 Read more

[src]

pub 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 行为]。 Read more

[src]

pub 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 行为]。 Read more

[src]

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

🔬 This is a nightly-only experimental API. (slice_index_methods)

返回此位置输出的共享引用，如果越界则会触发 panic。 Read more

[src]

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

🔬 This is a nightly-only experimental API. (slice_index_methods)

返回此位置输出的变量引用，如果越界则会触发 panic。 Read more

[src]

impl ToOwned for str

type Owned = String

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

[src]

pub fn to_owned(&self) -> String

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

[src]

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

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

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

[src]

impl ToSocketAddrs for str

type Iter = IntoIter<SocketAddr>

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

[src]

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

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

1.9.0[src]

impl ToString for str

[src]

pub fn to_string(&self) -> String

将给定值转换为 String。 Read more

[src]

impl Eq 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

[src]

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

[src]

pub fn type_id(&self) -> TypeId

获取 self 的 TypeId。 Read more

[src]

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

[src]

pub fn borrow(&self) -> &T

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

[src]

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

[src]

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

从拥有的值中借用。 Read more

[src]

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

[src]

pub default fn to_string(&self) -> String

将给定值转换为 String。 Read more

Primitive Type str1.0.0[−]

Implementations

impl str

pub const fn len(&self) -> usize

pub const fn is_empty(&self) -> bool

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

pub const fn as_bytes(&self) -> &[u8]ⓘNotable traits for &[u8]impl Read for &[u8]impl Write for &mut [u8]

pub unsafe fn as_bytes_mut(&mut self) -> &mut [u8]ⓘNotable traits for &[u8]impl Read for &[u8]impl Write for &mut [u8]

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

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

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

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

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

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

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

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

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

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

pub fn chars(&self) -> Chars<'_>ⓘNotable traits for Chars<'a>impl<'a> Iterator for Chars<'a> type Item = char;

pub fn char_indices(&self) -> CharIndices<'_>ⓘNotable traits for CharIndices<'a>impl<'a> Iterator for CharIndices<'a> type Item = (usize, char);

pub fn bytes(&self) -> Bytes<'_>ⓘNotable traits for Bytes<'_>impl<'_> Iterator for Bytes<'_> type Item = u8;

pub fn split_whitespace(&self) -> SplitWhitespace<'_>ⓘNotable traits for SplitWhitespace<'a>impl<'a> Iterator for SplitWhitespace<'a> type Item = &'a str;

pub fn split_ascii_whitespace(&self) -> SplitAsciiWhitespace<'_>ⓘNotable traits for SplitAsciiWhitespace<'a>impl<'a> Iterator for SplitAsciiWhitespace<'a> type Item = &'a str;

pub fn lines(&self) -> Lines<'_>ⓘNotable traits for Lines<'a>impl<'a> Iterator for Lines<'a> type Item = &'a str;

pub fn lines_any(&self) -> LinesAny<'_>ⓘNotable traits for LinesAny<'a>impl<'a> Iterator for LinesAny<'a> type Item = &'a str;

pub fn encode_utf16(&self) -> EncodeUtf16<'_>ⓘNotable traits for EncodeUtf16<'a>impl<'a> Iterator for EncodeUtf16<'a> type Item = u16;

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

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

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

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

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

pub fn split<'a, P>(&'a self, pat: P) -> Split<'a, P>ⓘNotable traits for Split<'a, P>impl<'a, P> Iterator for Split<'a, P> where P: Pattern<'a>, type Item = &'a str; where P: Pattern<'a>,

pub fn split_inclusive<'a, P>(&'a self, pat: P) -> SplitInclusive<'a, P>ⓘNotable traits for SplitInclusive<'a, P>impl<'a, P> Iterator for SplitInclusive<'a, P> where P: Pattern<'a>, type Item = &'a str; where P: Pattern<'a>,

pub fn rsplit<'a, P>(&'a self, pat: P) -> RSplit<'a, P>ⓘNotable traits for RSplit<'a, P>impl<'a, P> Iterator for RSplit<'a, P> where P: Pattern<'a>, <P as Pattern<'a>>::Searcher: ReverseSearcher<'a>, type Item = &'a str; where P: Pattern<'a>, <P as Pattern<'a>>::Searcher: ReverseSearcher<'a>,

pub fn split_terminator<'a, P>(&'a self, pat: P) -> SplitTerminator<'a, P>ⓘNotable traits for SplitTerminator<'a, P>impl<'a, P> Iterator for SplitTerminator<'a, P> where P: Pattern<'a>, type Item = &'a str; where P: Pattern<'a>,

pub fn splitn<'a, P>(&'a self, n: usize, pat: P) -> SplitN<'a, P>ⓘNotable traits for SplitN<'a, P>impl<'a, P> Iterator for SplitN<'a, P> where P: Pattern<'a>, type Item = &'a str; where P: Pattern<'a>,

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

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>,

pub fn matches<'a, P>(&'a self, pat: P) -> Matches<'a, P>ⓘNotable traits for Matches<'a, P>impl<'a, P> Iterator for Matches<'a, P> where P: Pattern<'a>, type Item = &'a str; where P: Pattern<'a>,

pub fn match_indices<'a, P>(&'a self, pat: P) -> MatchIndices<'a, P>ⓘNotable traits for MatchIndices<'a, P>impl<'a, P> Iterator for MatchIndices<'a, P> where P: Pattern<'a>, type Item = (usize, &'a str); where P: Pattern<'a>,

pub fn trim(&self) -> &str

pub fn trim_start(&self) -> &str

pub fn trim_end(&self) -> &str

pub fn trim_left(&self) -> &str

pub fn trim_right(&self) -> &str

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

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

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

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

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

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

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

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

pub fn is_ascii(&self) -> bool

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

pub fn make_ascii_uppercase(&mut self)

pub fn make_ascii_lowercase(&mut self)

pub const fn as_bytes(&self) -> &[u8 ]ⓘ
Notable traits for &[u8 ]
`impl Read for &[u8]impl Write for &mut [u8]`

pub unsafe fn as_bytes_mut(&mut self) -> &mut [u8 ]ⓘ
Notable traits for &[u8 ]
`impl Read for &[u8]impl Write for &mut [u8]`

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

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

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

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

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

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

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

pub fn chars(&self) -> Chars<'_>ⓘ
Notable traits for Chars<'a>
`impl<'a> Iterator for Chars<'a> type Item = char;`

pub fn char_indices(&self) -> CharIndices<'_>ⓘ
Notable traits for CharIndices<'a>
`impl<'a> Iterator for CharIndices<'a> type Item = (usize, char);`

pub fn bytes(&self) -> Bytes<'_>ⓘ
Notable traits for Bytes<'_>
`impl<'_> Iterator for Bytes<'_> type Item = u8;`

pub fn split_whitespace(&self) -> SplitWhitespace<'_>ⓘ
Notable traits for SplitWhitespace<'a>
`impl<'a> Iterator for SplitWhitespace<'a> type Item = &'a str;`

pub fn split_ascii_whitespace(&self) -> SplitAsciiWhitespace<'_>ⓘ
Notable traits for SplitAsciiWhitespace<'a>
`impl<'a> Iterator for SplitAsciiWhitespace<'a> type Item = &'a str;`

pub fn lines(&self) -> Lines<'_>ⓘ
Notable traits for Lines<'a>
`impl<'a> Iterator for Lines<'a> type Item = &'a str;`

pub fn lines_any(&self) -> LinesAny<'_>ⓘ
Notable traits for LinesAny<'a>
`impl<'a> Iterator for LinesAny<'a> type Item = &'a str;`

pub fn encode_utf16(&self) -> EncodeUtf16<'_>ⓘ
Notable traits for EncodeUtf16<'a>
`impl<'a> Iterator for EncodeUtf16<'a> type Item = u16;`

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

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

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

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

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

pub fn split<'a, P>(&'a self, pat: P) -> Split<'a, P>ⓘ
Notable traits for Split<'a, P>
`impl<'a, P> Iterator for Split<'a, P> where P: Pattern<'a>, type Item = &'a str;`
where
P: Pattern<'a>,

pub fn split_inclusive<'a, P>(&'a self, pat: P) -> SplitInclusive<'a, P>ⓘ
Notable traits for SplitInclusive<'a, P>
`impl<'a, P> Iterator for SplitInclusive<'a, P> where P: Pattern<'a>, type Item = &'a str;`
where
P: Pattern<'a>,

pub fn rsplit<'a, P>(&'a self, pat: P) -> RSplit<'a, P>ⓘ
Notable traits for RSplit<'a, P>
`impl<'a, P> Iterator for RSplit<'a, P> where P: Pattern<'a>, <P as Pattern<'a>>::Searcher: ReverseSearcher<'a>, type Item = &'a str;`
where
P: Pattern<'a>,
<P as Pattern<'a>>::Searcher: ReverseSearcher<'a>,

pub fn split_terminator<'a, P>(&'a self, pat: P) -> SplitTerminator<'a, P>ⓘ
Notable traits for SplitTerminator<'a, P>
`impl<'a, P> Iterator for SplitTerminator<'a, P> where P: Pattern<'a>, type Item = &'a str;`
where
P: Pattern<'a>,

pub fn splitn<'a, P>(&'a self, n: usize, pat: P) -> SplitN<'a, P>ⓘ
Notable traits for SplitN<'a, P>
`impl<'a, P> Iterator for SplitN<'a, P> where P: Pattern<'a>, type Item = &'a str;`
where
P: Pattern<'a>,

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

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>,

pub fn matches<'a, P>(&'a self, pat: P) -> Matches<'a, P>ⓘ
Notable traits for Matches<'a, P>
`impl<'a, P> Iterator for Matches<'a, P> where P: Pattern<'a>, type Item = &'a str;`
where
P: Pattern<'a>,

pub fn match_indices<'a, P>(&'a self, pat: P) -> MatchIndices<'a, P>ⓘ
Notable traits for MatchIndices<'a, P>
`impl<'a, P> Iterator for MatchIndices<'a, P> where P: Pattern<'a>, type Item = (usize, &'a str);`
where
P: Pattern<'a>,

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

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

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

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

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

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

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

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