Primitive Type str
1.0.0 ·Expand description
字符串切片。
str
类型,也称为字符串切片,是最原始的字符串类型。它通常以其借用形式 &str
出现。
也是字符串字面量的类型,&'static str
。
字符串切片始终是有效的 UTF-8。
基本用法
字符串字面量是字符串切片:
let hello_world = "Hello, World!";
Run这里我们声明了一个用字符串字面量初始化的字符串切片。
字符串字面量具有静态的生命周期,这意味着字符串 hello_world
在整个程序期间均有效。
我们也可以明确指定 hello_world
的生命周期:
let hello_world: &'static str = "Hello, world!";
RunRepresentation
&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));
RunNote: 本示例显示了 &str
的内部结构。在正常情况下,不应使用 unsafe
来获取字符串切片。
请改用 as_str
。
Implementations§
source§impl str
impl str
1.9.0 · sourcepub fn is_char_boundary(&self, index: usize) -> bool
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));
Runsourcepub fn floor_char_boundary(&self, index: usize) -> usize
🔬This is a nightly-only experimental API. (round_char_boundary
#93743)
pub fn floor_char_boundary(&self, index: usize) -> usize
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], "❤️🧡");
Runsourcepub fn ceil_char_boundary(&self, index: usize) -> usize
🔬This is a nightly-only experimental API. (round_char_boundary
#93743)
pub fn ceil_char_boundary(&self, index: usize) -> usize
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], "❤️🧡💛");
Run1.20.0 · sourcepub unsafe fn as_bytes_mut(&mut self) -> &mut [u8]
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);
RunMutability:
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);
Runconst: 1.32.0 · sourcepub const fn as_ptr(&self) -> *const u8
pub const fn as_ptr(&self) -> *const u8
将字符串切片转换为裸指针。
由于字符串切片是字节的切片,所以裸指针指向 u8
。
该指针将指向字符串切片的第一个字节。
调用者必须确保返回的指针永远不会被写入。
如果需要更改字符串切片的内容,请使用 as_mut_ptr
。
Examples
基本用法:
let s = "Hello";
let ptr = s.as_ptr();
Run1.36.0 · sourcepub fn as_mut_ptr(&mut self) -> *mut u8
pub fn as_mut_ptr(&mut self) -> *mut u8
1.20.0 · sourcepub fn get_mut<I: SliceIndex<str>>(&mut self, i: I) -> Option<&mut I::Output>
pub fn get_mut<I: SliceIndex<str>>(&mut self, i: I) -> Option<&mut I::Output>
返回 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);
Run1.20.0 · sourcepub unsafe fn get_unchecked<I: SliceIndex<str>>(&self, i: I) -> &I::Output
pub unsafe fn get_unchecked<I: SliceIndex<str>>(&self, i: I) -> &I::Output
返回未经检查的 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));
}
Run1.20.0 · sourcepub unsafe fn get_unchecked_mut<I: SliceIndex<str>>(
&mut self,
i: I
) -> &mut I::Output
pub unsafe fn get_unchecked_mut<I: SliceIndex<str>>( &mut self, i: I ) -> &mut I::Output
返回 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));
}
Runsourcepub unsafe fn slice_unchecked(&self, begin: usize, end: usize) -> &str
👎Deprecated since 1.29.0: use get_unchecked(begin..end)
instead
pub unsafe fn slice_unchecked(&self, begin: usize, end: usize) -> &str
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));
}
Run1.5.0 · sourcepub 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
pub unsafe fn slice_mut_unchecked( &mut self, begin: usize, end: usize ) -> &mut str
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 · sourcepub fn split_at(&self, mid: usize) -> (&str, &str)
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);
Run1.4.0 · sourcepub fn split_at_mut(&mut self, mid: usize) -> (&mut str, &mut str)
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);
Runsourcepub fn chars(&self) -> Chars<'_> ⓘ
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());
Runsourcepub fn char_indices(&self) -> CharIndices<'_> ⓘ
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());
Run1.1.0 · sourcepub fn split_whitespace(&self) -> SplitWhitespace<'_> ⓘ
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);
Run1.34.0 · sourcepub fn split_ascii_whitespace(&self) -> SplitAsciiWhitespace<'_> ⓘ
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);
Runsourcepub fn lines(&self) -> Lines<'_> ⓘ
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());
Runsourcepub fn lines_any(&self) -> LinesAny<'_> ⓘ
👎Deprecated since 1.4.0: use lines() instead now
pub fn lines_any(&self) -> LinesAny<'_> ⓘ
字符串行上的迭代器。
1.8.0 · sourcepub fn encode_utf16(&self) -> EncodeUtf16<'_> ⓘ
pub fn encode_utf16(&self) -> EncodeUtf16<'_> ⓘ
sourcepub fn starts_with<'a, P: Pattern<'a>>(&'a self, pat: P) -> bool
pub fn starts_with<'a, P: Pattern<'a>>(&'a self, pat: P) -> bool
sourcepub fn ends_with<'a, P>(&'a self, pat: P) -> boolwhere
P: Pattern<'a, Searcher: ReverseSearcher<'a>>,
pub fn ends_with<'a, P>(&'a self, pat: P) -> boolwhere P: Pattern<'a, Searcher: ReverseSearcher<'a>>,
sourcepub fn find<'a, P: Pattern<'a>>(&'a self, pat: P) -> Option<usize>
pub fn find<'a, P: Pattern<'a>>(&'a self, pat: P) -> Option<usize>
返回此字符串切片中与模式匹配的第一个字符的字节索引。
如果模式不匹配,则返回 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);
Runsourcepub fn rfind<'a, P>(&'a self, pat: P) -> Option<usize>where
P: Pattern<'a, Searcher: ReverseSearcher<'a>>,
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);
Runsourcepub fn split<'a, P: Pattern<'a>>(&'a self, pat: P) -> Split<'a, P> ⓘ
pub fn split<'a, P: Pattern<'a>>(&'a self, pat: P) -> Split<'a, P> ⓘ
在此字符串切片的子字符串上进行迭代的迭代器,该子字符串由模式匹配的字符分隔。
模式 可以是 &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它确实不会给您:
为此行为使用 split_whitespace
。
1.51.0 · sourcepub fn split_inclusive<'a, P: Pattern<'a>>(
&'a self,
pat: P
) -> SplitInclusive<'a, P> ⓘ
pub fn split_inclusive<'a, P: Pattern<'a>>( &'a self, pat: P ) -> SplitInclusive<'a, P> ⓘ
在此字符串切片的子字符串上进行迭代的迭代器,该子字符串由模式匹配的字符分隔。
与 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"]);
Runsourcepub fn rsplit<'a, P>(&'a self, pat: P) -> RSplit<'a, P> ⓘwhere
P: Pattern<'a, Searcher: ReverseSearcher<'a>>,
pub fn rsplit<'a, P>(&'a self, pat: P) -> RSplit<'a, P> ⓘ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"]);
Runsourcepub fn split_terminator<'a, P: Pattern<'a>>(
&'a self,
pat: P
) -> SplitTerminator<'a, P> ⓘ
pub fn split_terminator<'a, P: Pattern<'a>>( &'a self, pat: P ) -> SplitTerminator<'a, P> ⓘ
给定字符串切片的子字符串上的迭代器,该子字符串由模式匹配的字符分隔。
模式 可以是 &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"]);
Runsourcepub fn rsplit_terminator<'a, P>(&'a self, pat: P) -> RSplitTerminator<'a, P> ⓘwhere
P: Pattern<'a, Searcher: ReverseSearcher<'a>>,
pub fn rsplit_terminator<'a, P>(&'a self, pat: P) -> RSplitTerminator<'a, P> ⓘ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"]);
Runsourcepub fn splitn<'a, P: Pattern<'a>>(&'a self, n: usize, pat: P) -> SplitN<'a, P> ⓘ
pub fn splitn<'a, P: Pattern<'a>>(&'a self, n: usize, pat: P) -> SplitN<'a, P> ⓘ
给定字符串切片的子字符串上的迭代器 (由模式分隔),仅限于返回最多 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"]);
Runsourcepub fn rsplitn<'a, P>(&'a self, n: usize, pat: P) -> RSplitN<'a, P> ⓘwhere
P: Pattern<'a, Searcher: ReverseSearcher<'a>>,
pub fn rsplitn<'a, P>(&'a self, n: usize, pat: P) -> RSplitN<'a, P> ⓘ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"]);
Run1.52.0 · sourcepub fn split_once<'a, P: Pattern<'a>>(
&'a self,
delimiter: P
) -> Option<(&'a str, &'a str)>
pub fn split_once<'a, P: Pattern<'a>>( &'a self, delimiter: P ) -> Option<(&'a str, &'a str)>
1.52.0 · sourcepub fn rsplit_once<'a, P>(&'a self, delimiter: P) -> Option<(&'a str, &'a str)>where
P: Pattern<'a, Searcher: ReverseSearcher<'a>>,
pub fn rsplit_once<'a, P>(&'a self, delimiter: P) -> Option<(&'a str, &'a str)>where P: Pattern<'a, Searcher: ReverseSearcher<'a>>,
1.2.0 · sourcepub fn matches<'a, P: Pattern<'a>>(&'a self, pat: P) -> Matches<'a, P> ⓘ
pub fn matches<'a, P: Pattern<'a>>(&'a self, pat: P) -> Matches<'a, P> ⓘ
给定字符串切片中某个模式的不相交匹配的迭代器。
模式 可以是 &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"]);
Run1.2.0 · sourcepub fn rmatches<'a, P>(&'a self, pat: P) -> RMatches<'a, P> ⓘwhere
P: Pattern<'a, Searcher: ReverseSearcher<'a>>,
pub fn rmatches<'a, P>(&'a self, pat: P) -> RMatches<'a, P> ⓘ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"]);
Run1.5.0 · sourcepub fn match_indices<'a, P: Pattern<'a>>(
&'a self,
pat: P
) -> MatchIndices<'a, P> ⓘ
pub fn match_indices<'a, P: Pattern<'a>>( &'a self, pat: P ) -> MatchIndices<'a, P> ⓘ
对该字符串切片中某个模式的不相交匹配以及该匹配开始处的索引的迭代器。
对于 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`
Run1.5.0 · sourcepub fn rmatch_indices<'a, P>(&'a self, pat: P) -> RMatchIndices<'a, P> ⓘwhere
P: Pattern<'a, Searcher: ReverseSearcher<'a>>,
pub fn rmatch_indices<'a, P>(&'a self, pat: P) -> RMatchIndices<'a, P> ⓘ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`
Run1.30.0 · sourcepub fn trim_start(&self) -> &str
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());
RunDirectionality:
let s = " English ";
assert!(Some('E') == s.trim_start().chars().next());
let s = " עברית ";
assert!(Some('ע') == s.trim_start().chars().next());
Run1.30.0 · sourcepub fn trim_end(&self) -> &str
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());
RunDirectionality:
let s = " English ";
assert!(Some('h') == s.trim_end().chars().rev().next());
let s = " עברית ";
assert!(Some('ת') == s.trim_end().chars().rev().next());
Runsourcepub fn trim_left(&self) -> &str
👎Deprecated since 1.33.0: superseded by trim_start
pub fn trim_left(&self) -> &str
trim_start
返回除去前导空格的字符串切片。
‘Whitespace’ 是根据 Unicode 派生核心属性 White_Space
的条款定义的。
文字方向性
字符串是字节序列。 ‘Left’ 在此上下文中表示该字节字符串的第一个位置; 对于像阿拉伯语或希伯来语这样从右到左而不是从左到右的语言,这将是右侧,而不是左侧。
Examples
基本用法:
let s = " Hello\tworld\t";
assert_eq!("Hello\tworld\t", s.trim_left());
RunDirectionality:
let s = " English";
assert!(Some('E') == s.trim_left().chars().next());
let s = " עברית";
assert!(Some('ע') == s.trim_left().chars().next());
Runsourcepub fn trim_right(&self) -> &str
👎Deprecated since 1.33.0: superseded by trim_end
pub fn trim_right(&self) -> &str
trim_end
返回除去尾随空格的字符串切片。
‘Whitespace’ 是根据 Unicode 派生核心属性 White_Space
的条款定义的。
文字方向性
字符串是字节序列。 ‘Right’ 在此上下文中表示该字节字符串的最后位置; 对于像阿拉伯语或希伯来语这样从右到左而不是从左到右的语言,这将是左侧,而不是右侧。
Examples
基本用法:
let s = " Hello\tworld\t";
assert_eq!(" Hello\tworld", s.trim_right());
RunDirectionality:
let s = "English ";
assert!(Some('h') == s.trim_right().chars().rev().next());
let s = "עברית ";
assert!(Some('ת') == s.trim_right().chars().rev().next());
Runsourcepub fn trim_matches<'a, P>(&'a self, pat: P) -> &'a strwhere
P: Pattern<'a, Searcher: DoubleEndedSearcher<'a>>,
pub fn trim_matches<'a, P>(&'a self, pat: P) -> &'a strwhere 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");
Run1.30.0 · sourcepub fn trim_start_matches<'a, P: Pattern<'a>>(&'a self, pat: P) -> &'a str
pub fn trim_start_matches<'a, P: Pattern<'a>>(&'a self, pat: P) -> &'a str
返回字符串切片,该字符串切片的所有前缀都与重复删除的模式匹配。
模式 可以是 &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");
Run1.45.0 · sourcepub fn strip_prefix<'a, P: Pattern<'a>>(&'a self, prefix: P) -> Option<&'a str>
pub fn strip_prefix<'a, P: Pattern<'a>>(&'a self, prefix: P) -> Option<&'a str>
返回删除了前缀的字符串切片。
如果字符串以模式 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"));
Run1.45.0 · sourcepub 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 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"));
Run1.30.0 · sourcepub fn trim_end_matches<'a, P>(&'a self, pat: P) -> &'a strwhere
P: Pattern<'a, Searcher: ReverseSearcher<'a>>,
pub fn trim_end_matches<'a, P>(&'a self, pat: P) -> &'a strwhere 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");
Runsourcepub fn trim_left_matches<'a, P: Pattern<'a>>(&'a self, pat: P) -> &'a str
👎Deprecated since 1.33.0: superseded by trim_start_matches
pub fn trim_left_matches<'a, P: Pattern<'a>>(&'a self, pat: P) -> &'a str
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");
Runsourcepub fn trim_right_matches<'a, P>(&'a self, pat: P) -> &'a strwhere
P: Pattern<'a, Searcher: ReverseSearcher<'a>>,
👎Deprecated since 1.33.0: superseded by trim_end_matches
pub fn trim_right_matches<'a, P>(&'a self, pat: P) -> &'a strwhere P: Pattern<'a, Searcher: ReverseSearcher<'a>>,
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");
Runsourcepub fn parse<F: FromStr>(&self) -> Result<F, F::Err>
pub fn parse<F: FromStr>(&self) -> Result<F, F::Err>
将此字符串切片解析为另一种类型。
由于 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());
Runsourcepub const fn as_ascii(&self) -> Option<&[Char]>
🔬This is a nightly-only experimental API. (ascii_char
#110998)
pub const fn as_ascii(&self) -> Option<&[Char]>
ascii_char
#110998)如果此字符串切片 is_ascii
,则将其作为 ASCII characters 的切片返回,否则返回 None
。
1.23.0 · sourcepub fn eq_ignore_ascii_case(&self, other: &str) -> bool
pub fn eq_ignore_ascii_case(&self, other: &str) -> bool
1.23.0 · sourcepub fn make_ascii_uppercase(&mut self)
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);
Run1.23.0 · sourcepub fn make_ascii_lowercase(&mut self)
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);
Run1.34.0 · sourcepub fn escape_debug(&self) -> EscapeDebug<'_> ⓘ
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!");
Run1.34.0 · sourcepub fn escape_default(&self) -> EscapeDefault<'_> ⓘ
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!");
Run1.34.0 · sourcepub fn escape_unicode(&self) -> EscapeUnicode<'_> ⓘ
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}");
RunTrait Implementations§
source§impl !Error for &str
impl !Error for &str
source§impl Ord for str
impl Ord for str
实现字符串排序。
字符串按字节值按 按字典顺序 排序。
这将根据 Unicode 代码点在代码图中的位置进行排序。
这不一定与 “alphabetical” 顺序相同,后者因语言和区域设置而异。
根据文化认可的标准对字符串进行排序需要 str
类型的作用域之外的特定于语言环境的数据。
source§impl PartialOrd<str> for str
impl PartialOrd<str> for str
对字符串执行比较操作。
按字典顺序 通过字符串的字节值对字符串进行比较。
这将根据 Unicode 代码点在代码表中的位置进行比较。
这不一定与 “alphabetical” 顺序相同,后者因语言和区域设置而异。
根据文化认可的标准比较字符串需要特定于语言环境的数据,该数据不在 str
类型的作用域之内。
source§impl<'a, 'b> Pattern<'a> for &'b str
impl<'a, 'b> Pattern<'a> for &'b str
source§fn is_prefix_of(self, haystack: &'a str) -> bool
🔬This is a nightly-only experimental API. (pattern
#27721)
fn is_prefix_of(self, haystack: &'a str) -> bool
pattern
#27721)检查模式在 haystack 的前面是否匹配。
source§fn is_contained_in(self, haystack: &'a str) -> bool
🔬This is a nightly-only experimental API. (pattern
#27721)
fn is_contained_in(self, haystack: &'a str) -> bool
pattern
#27721)检查模式是否与 haystack 中的任何位置匹配
source§fn strip_prefix_of(self, haystack: &'a str) -> Option<&'a str>
🔬This is a nightly-only experimental API. (pattern
#27721)
fn strip_prefix_of(self, haystack: &'a str) -> Option<&'a str>
pattern
#27721)如果匹配,则从 haystack 的正面删除模式。
source§fn is_suffix_of(self, haystack: &'a str) -> bool
🔬This is a nightly-only experimental API. (pattern
#27721)
fn is_suffix_of(self, haystack: &'a str) -> bool
pattern
#27721)检查模式是否与 haystack 的后面匹配。
source§fn strip_suffix_of(self, haystack: &'a str) -> Option<&'a str>
🔬This is a nightly-only experimental API. (pattern
#27721)
fn strip_suffix_of(self, haystack: &'a str) -> Option<&'a str>
pattern
#27721)如果匹配,则从 haystack 的后面删除模式。
§type Searcher = StrSearcher<'a, 'b>
type Searcher = StrSearcher<'a, 'b>
pattern
#27721)source§fn into_searcher(self, haystack: &'a str) -> StrSearcher<'a, 'b>
fn into_searcher(self, haystack: &'a str) -> StrSearcher<'a, 'b>
pattern
#27721)self
和 haystack
构造关联的搜索器以进行搜索。1.20.0 (const: unstable) · source§impl SliceIndex<str> for Range<usize>
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];
Runconst: unstable · source§fn get(self, slice: &str) -> Option<&Self::Output>
fn get(self, slice: &str) -> Option<&Self::Output>
slice_index_methods
)const: unstable · source§fn get_mut(self, slice: &mut str) -> Option<&mut Self::Output>
fn get_mut(self, slice: &mut str) -> Option<&mut Self::Output>
slice_index_methods
)const: unstable · source§unsafe fn get_unchecked(self, slice: *const str) -> *const Self::Output
unsafe fn get_unchecked(self, slice: *const str) -> *const Self::Output
slice_index_methods
)slice
指针调用此方法也是 [undefined 行为]。const: unstable · source§unsafe fn get_unchecked_mut(self, slice: *mut str) -> *mut Self::Output
unsafe fn get_unchecked_mut(self, slice: *mut str) -> *mut Self::Output
slice_index_methods
)slice
指针调用此方法也是 [undefined 行为]。1.20.0 (const: unstable) · source§impl SliceIndex<str> for RangeFrom<usize>
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。
const: unstable · source§fn get(self, slice: &str) -> Option<&Self::Output>
fn get(self, slice: &str) -> Option<&Self::Output>
slice_index_methods
)const: unstable · source§fn get_mut(self, slice: &mut str) -> Option<&mut Self::Output>
fn get_mut(self, slice: &mut str) -> Option<&mut Self::Output>
slice_index_methods
)const: unstable · source§unsafe fn get_unchecked(self, slice: *const str) -> *const Self::Output
unsafe fn get_unchecked(self, slice: *const str) -> *const Self::Output
slice_index_methods
)slice
指针调用此方法也是 [undefined 行为]。const: unstable · source§unsafe fn get_unchecked_mut(self, slice: *mut str) -> *mut Self::Output
unsafe fn get_unchecked_mut(self, slice: *mut str) -> *mut Self::Output
slice_index_methods
)slice
指针调用此方法也是 [undefined 行为]。1.20.0 (const: unstable) · source§impl SliceIndex<str> for RangeFull
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]
。
const: unstable · source§fn get(self, slice: &str) -> Option<&Self::Output>
fn get(self, slice: &str) -> Option<&Self::Output>
slice_index_methods
)const: unstable · source§fn get_mut(self, slice: &mut str) -> Option<&mut Self::Output>
fn get_mut(self, slice: &mut str) -> Option<&mut Self::Output>
slice_index_methods
)const: unstable · source§unsafe fn get_unchecked(self, slice: *const str) -> *const Self::Output
unsafe fn get_unchecked(self, slice: *const str) -> *const Self::Output
slice_index_methods
)slice
指针调用此方法也是 [undefined 行为]。const: unstable · source§unsafe fn get_unchecked_mut(self, slice: *mut str) -> *mut Self::Output
unsafe fn get_unchecked_mut(self, slice: *mut str) -> *mut Self::Output
slice_index_methods
)slice
指针调用此方法也是 [undefined 行为]。1.26.0 (const: unstable) · source§impl SliceIndex<str> for RangeInclusive<usize>
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。
const: unstable · source§fn get(self, slice: &str) -> Option<&Self::Output>
fn get(self, slice: &str) -> Option<&Self::Output>
slice_index_methods
)const: unstable · source§fn get_mut(self, slice: &mut str) -> Option<&mut Self::Output>
fn get_mut(self, slice: &mut str) -> Option<&mut Self::Output>
slice_index_methods
)const: unstable · source§unsafe fn get_unchecked(self, slice: *const str) -> *const Self::Output
unsafe fn get_unchecked(self, slice: *const str) -> *const Self::Output
slice_index_methods
)slice
指针调用此方法也是 [undefined 行为]。const: unstable · source§unsafe fn get_unchecked_mut(self, slice: *mut str) -> *mut Self::Output
unsafe fn get_unchecked_mut(self, slice: *mut str) -> *mut Self::Output
slice_index_methods
)slice
指针调用此方法也是 [undefined 行为]。1.20.0 (const: unstable) · source§impl SliceIndex<str> for RangeTo<usize>
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。
const: unstable · source§fn get(self, slice: &str) -> Option<&Self::Output>
fn get(self, slice: &str) -> Option<&Self::Output>
slice_index_methods
)const: unstable · source§fn get_mut(self, slice: &mut str) -> Option<&mut Self::Output>
fn get_mut(self, slice: &mut str) -> Option<&mut Self::Output>
slice_index_methods
)const: unstable · source§unsafe fn get_unchecked(self, slice: *const str) -> *const Self::Output
unsafe fn get_unchecked(self, slice: *const str) -> *const Self::Output
slice_index_methods
)slice
指针调用此方法也是 [undefined 行为]。const: unstable · source§unsafe fn get_unchecked_mut(self, slice: *mut str) -> *mut Self::Output
unsafe fn get_unchecked_mut(self, slice: *mut str) -> *mut Self::Output
slice_index_methods
)slice
指针调用此方法也是 [undefined 行为]。1.26.0 (const: unstable) · source§impl SliceIndex<str> for RangeToInclusive<usize>
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。
const: unstable · source§fn get(self, slice: &str) -> Option<&Self::Output>
fn get(self, slice: &str) -> Option<&Self::Output>
slice_index_methods
)const: unstable · source§fn get_mut(self, slice: &mut str) -> Option<&mut Self::Output>
fn get_mut(self, slice: &mut str) -> Option<&mut Self::Output>
slice_index_methods
)const: unstable · source§unsafe fn get_unchecked(self, slice: *const str) -> *const Self::Output
unsafe fn get_unchecked(self, slice: *const str) -> *const Self::Output
slice_index_methods
)slice
指针调用此方法也是 [undefined 行为]。const: unstable · source§unsafe fn get_unchecked_mut(self, slice: *mut str) -> *mut Self::Output
unsafe fn get_unchecked_mut(self, slice: *mut str) -> *mut Self::Output
slice_index_methods
)slice
指针调用此方法也是 [undefined 行为]。