pub struct String { /* private fields */ }
Expand description
一个 UTF-8 编码的可增长字符串。
String
类型是最常见的字符串类型,拥有对该字符串内容的所有权。它与其借用的对应物,原始的 str
有着密切的关系。
Examples
您可以使用 String::from
从一个 字符串字面量 创建一个 String
:
let hello = String::from("Hello, world!");
Run您可以使用 push
方法将 char
追加到 String
上,并使用 push_str
方法追加 &str
:
let mut hello = String::from("Hello, ");
hello.push('w');
hello.push_str("orld!");
Run如果具有 UTF-8 字节的 vector,则可以使用 from_utf8
方法从中创建一个 String
:
// vector 中的一些字节
let sparkle_heart = vec![240, 159, 146, 150];
// 我们知道这些字节是有效的,因此我们将使用 `unwrap()`。
let sparkle_heart = String::from_utf8(sparkle_heart).unwrap();
assert_eq!("💖", sparkle_heart);
RunUTF-8
String
s 始终是有效的 UTF-8。如果您需要非 UTF-8 字符串,请考虑 OsString
。它是相似的,但是没有 UTF-8 约束。因为 UTF-8 是可变宽度的编码,String
s 通常小于相同 chars
的数组:
use std::mem;
// `s` 是 ASCII 码,它表示每个 `char` 为一个字节
let s = "hello";
assert_eq!(s.len(), 5);
// 具有相同内容的 `char` 数组会更长,因为每个 `char` 都是四个字节
let s = ['h', 'e', 'l', 'l', 'o'];
let size: usize = s.into_iter().map(|c| mem::size_of_val(&c)).sum();
assert_eq!(size, 20);
// 但是,对于非 ASCII 字符串,差异会更小,有时它们是相同的
let s = "💖💖💖💖💖";
assert_eq!(s.len(), 20);
let s = ['💖', '💖', '💖', '💖', '💖'];
let size: usize = s.into_iter().map(|c| mem::size_of_val(&c)).sum();
assert_eq!(size, 20);
Run这就提出了一些有趣的问题,比如 s[i]
应该如何工作。
i
在这里应该是什么? 几个选项包括字节索引和 char
索引,但由于 UTF-8 编码,只有字节索引会提供时间特性索引。例如,可以使用 chars
获取第 i 个 char
:
let s = "hello";
let third_character = s.chars().nth(2);
assert_eq!(third_character, Some('l'));
let s = "💖💖💖💖💖";
let third_character = s.chars().nth(2);
assert_eq!(third_character, Some('💖'));
Run接下来,s[i]
应该返回什么? 因为索引会返回对,底层,数据的引用,所以它可能是 &u8
、&[u8]
或其他类似的东西。
由于我们只提供一个索引,&u8
是最有意义的,但这可能不是用户所期望的,并且可以通过
as_bytes()
:
// 第一个字节是 104-`'h'` 的字节值
let s = "hello";
assert_eq!(s.as_bytes()[0], 104);
// or
assert_eq!(s.as_bytes()[0], b'h');
// 第一个字节是 240 这显然没有用
let s = "💖💖💖💖💖";
assert_eq!(s.as_bytes()[0], 240);
Run由于这些歧义或限制,简单地禁止使用 usize
进行索引:
然而,更清楚的是 &s[i..j]
应该如何工作 (即,使用范围进行索引)。它应该接受字节索引 (作为特征时间) 并返回一个 &str
,它是 UTF-8 编码的。这也称为 “字符串切片”。
请注意,如果提供的字节索引不是字符边界,这将导致 panic - 有关更多详细信息,请参见 is_char_boundary
。有关字符串切片的更多详细信息,请参见 SliceIndex<str>
的实现。有关字符串切片的非 panic 版本,请参见 get
。
bytes
和 chars
方法分别返回字符串的字节和代码点的迭代器。要迭代代码点和字节索引,请使用 char_indices
。
Deref
String
实现了 Deref<Target = str>
,因此继承了 str
的所有方法。另外,这意味着您可以使用与号 (&
) 将 String
传递给采用 &str
的函数:
fn takes_str(s: &str) { }
let s = String::from("Hello");
takes_str(&s);
Run这将从 String
创建一个 &str
,并将其传入。这种转换非常便宜,因此通常,函数会接受 &str
作为参数,除非出于某些特定原因它们需要 String
。
在某些情况下,Rust 没有足够的信息来进行此转换,称为 Deref
强制多态。在以下示例中,字符串切片 &'a str
实现 TraitExample
trait,函数 example_func
接受实现 trait 的所有内容。
在这种情况下,Rust 将需要进行两次隐式转换,而 Rust 没有办法进行转换。
因此,以下示例将无法编译。
trait TraitExample {}
impl<'a> TraitExample for &'a str {}
fn example_func<A: TraitExample>(example_arg: A) {}
let example_string = String::from("example_string");
example_func(&example_string);
Run有两种选择可以代替。第一种是使用方法 as_str()
显式提取包含该字符串的字符串切片,从而将 example_func(&example_string);
行更改为 example_func(example_string.as_str());
。
第二种方法将 example_func(&example_string);
更改为 example_func(&*example_string);
。
在这种情况下,我们将 String
解引用到 str
,然后将 str
引用回 &str
。
第二种方法更惯用,但是两种方法都可以显式地进行转换,而不是依赖于隐式转换。
Representation
String
由三个部分组成:指向某些字节的指针,长度和容量。指针指向 String
用于存储其数据的内部缓冲区。长度是当前存储在缓冲区中的字节数,容量是缓冲区的大小 (以字节为单位)。
这样,长度将始终小于或等于容量。
此缓冲区始终存储在堆中。
您可以使用 as_ptr
,len
和 capacity
方法查看它们:
use std::mem;
let story = String::from("Once upon a time...");
// 防止自动丢弃字符串的数据
let mut story = mem::ManuallyDrop::new(story);
let ptr = story.as_mut_ptr();
let len = story.len();
let capacity = story.capacity();
// story 有十九个字节
assert_eq!(19, len);
// 我们可以用 ptr,len 和 capacity 重新构建一个 String。
// 这都是不安全的,因为我们有责任确保组件有效:
let s = unsafe { String::from_raw_parts(ptr, len, capacity) } ;
assert_eq!(String::from("Once upon a time..."), s);
Run如果 String
具有足够的容量,则向其添加元素将不会重新分配。例如,考虑以下程序:
let mut s = String::new();
println!("{}", s.capacity());
for _ in 0..5 {
s.push_str("hello");
println!("{}", s.capacity());
}
Run这将输出以下内容:
0
8
16
16
32
32
最初,我们根本没有分配任何内存,但是当我们追加到字符串后,它会适当地增加其容量。如果我们改为使用 with_capacity
方法来初始分配正确的容量,请执行以下操作:
let mut s = String::with_capacity(25);
println!("{}", s.capacity());
for _ in 0..5 {
s.push_str("hello");
println!("{}", s.capacity());
}
Run我们最终得到了不同的输出:
25
25
25
25
25
25
在这里,不需要在循环内分配更多的内存。
Implementations§
source§impl String
impl String
const: 1.39.0 · sourcepub const fn new() -> String
pub const fn new() -> String
创建一个新的空 String
。
由于 String
为空,因此不会分配任何初始缓冲区。虽然这意味着该初始操作非常便宜,但在以后添加数据时可能会导致过多的分配。
如果您对 String
可以容纳多少数据有所了解,请考虑使用 with_capacity
方法来防止过多的重新分配。
Examples
基本用法:
let s = String::new();
Runsourcepub fn with_capacity(capacity: usize) -> String
pub fn with_capacity(capacity: usize) -> String
创建一个至少具有指定容量的新空 String
。
String
有一个内部缓冲区来保存其数据。
容量是该缓冲区的长度,可以使用 capacity
方法进行查询。
此方法创建一个空的 String
,但它的初始缓冲区至少可容纳 capacity
字节。
当您可能将一堆数据追加到 String
时,这很有用,从而减少了它需要进行的重新分配的次数。
如果给定的容量为 0
,则不会进行分配,并且此方法与 new
方法相同。
Examples
基本用法:
let mut s = String::with_capacity(10);
// 字符串不包含任何字符,即使它可以容纳更多字符
assert_eq!(s.len(), 0);
// 这些都是在不重新分配的情况下完成的...
let cap = s.capacity();
for _ in 0..10 {
s.push('a');
}
assert_eq!(s.capacity(), cap);
// ...但这可能会使字符串重新分配
s.push('a');
Runsourcepub fn from_utf8(vec: Vec<u8>) -> Result<String, FromUtf8Error>
pub fn from_utf8(vec: Vec<u8>) -> Result<String, FromUtf8Error>
将字节的 vector 转换为 String
。
字符串 (String
) 由字节 (u8
) 组成,字节 (Vec<u8>
) 的 vector 由字节组成,因此此函数在两者之间进行转换。
并非所有的字节片都是有效的 String
,但是: String
要求它是有效的 UTF-8。
from_utf8()
检查以确保字节是有效的 UTF-8,然后进行转换。
如果您确定字节切片是有效的 UTF-8,并且不想增加有效性检查的开销,则此函数有一个不安全的版本 from_utf8_unchecked
,它具有相同的行为,但是会跳过检查。
为了提高效率,此方法将注意不要复制 vector。
如果需要 &str
而不是 String
,请考虑使用 str::from_utf8
。
与此方法的相反的是 into_bytes
。
Errors
如果切片不是 UTF-8,则返回 Err
,并说明为什么提供的字节不是 UTF-8。还包括您移入的 vector。
Examples
基本用法:
// vector 中的一些字节
let sparkle_heart = vec![240, 159, 146, 150];
// 我们知道这些字节是有效的,因此我们将使用 `unwrap()`。
let sparkle_heart = String::from_utf8(sparkle_heart).unwrap();
assert_eq!("💖", sparkle_heart);
Run字节不正确:
// vector 中的一些无效字节
let sparkle_heart = vec![0, 159, 146, 150];
assert!(String::from_utf8(sparkle_heart).is_err());
Run请参见 FromUtf8Error
文档,以获取有关此错误的更多详细信息。
sourcepub fn from_utf8_lossy(v: &[u8]) -> Cow<'_, str>
pub fn from_utf8_lossy(v: &[u8]) -> Cow<'_, str>
将字节切片转换为字符串,包括无效字符。
字符串由字节 (u8
) 组成,而字节 (&[u8]
) 的切片由字节组成,因此此函数在两者之间进行转换。然而,并非所有的字节片都是有效的字符串,字符串必须是有效的 UTF-8。
在此转换过程中,from_utf8_lossy()
会将所有无效的 UTF-8 序列替换为 U+FFFD REPLACEMENT CHARACTER
,如下所示:
如果您确定字节切片是有效的 UTF-8,并且不想增加转换的开销,则此函数有一个不安全的版本 from_utf8_unchecked
,它具有相同的行为,但是会跳过检查。
此函数返回 Cow<'a, str>
。如果字节切片的 UTF-8 无效,则需要插入替换字符,这将更改字符串的大小,因此需要 String
。
但是,如果它已经是有效的 UTF-8,则不需要新的分配。
这种返回类型使我们能够处理两种情况。
Examples
基本用法:
// vector 中的一些字节
let sparkle_heart = vec![240, 159, 146, 150];
let sparkle_heart = String::from_utf8_lossy(&sparkle_heart);
assert_eq!("💖", sparkle_heart);
Run字节不正确:
// 一些无效的字节
let input = b"Hello \xF0\x90\x80World";
let output = String::from_utf8_lossy(input);
assert_eq!("Hello �World", output);
Runsourcepub fn from_utf16(v: &[u16]) -> Result<String, FromUtf16Error>
pub fn from_utf16(v: &[u16]) -> Result<String, FromUtf16Error>
将 UTF-16 编码的 vector v
解码为 String
,如果 v
包含任何无效数据,则返回 Err
。
Examples
基本用法:
// 𝄞music
let v = &[0xD834, 0xDD1E, 0x006d, 0x0075,
0x0073, 0x0069, 0x0063];
assert_eq!(String::from("𝄞music"),
String::from_utf16(v).unwrap());
// 𝄞mu<invalid>ic
let v = &[0xD834, 0xDD1E, 0x006d, 0x0075,
0xD800, 0x0069, 0x0063];
assert!(String::from_utf16(v).is_err());
Runsourcepub fn from_utf16_lossy(v: &[u16]) -> String
pub fn from_utf16_lossy(v: &[u16]) -> String
将 UTF-16 编码的切片 v
解码为 String
,将无效数据替换为 替换字符 (U+FFFD
)。
与 from_utf8_lossy
返回 Cow<'a, str>
不同,from_utf16_lossy
返回 String
,因为 UTF-16 到 UTF-8 的转换需要分配内存。
Examples
基本用法:
// 𝄞mus<invalid>ic<invalid>
let v = &[0xD834, 0xDD1E, 0x006d, 0x0075,
0x0073, 0xDD1E, 0x0069, 0x0063,
0xD834];
assert_eq!(String::from("𝄞mus\u{FFFD}ic\u{FFFD}"),
String::from_utf16_lossy(v));
Runsourcepub fn into_raw_parts(self) -> (*mut u8, usize, usize)
🔬This is a nightly-only experimental API. (vec_into_raw_parts
#65816)
pub fn into_raw_parts(self) -> (*mut u8, usize, usize)
vec_into_raw_parts
#65816)将 String
分解为其原始组件。
返回指向底层数据的裸指针,字符串的长度 (以字节为单位) 和数据的已分配容量 (以字节为单位)。
这些参数与 from_raw_parts
的参数顺序相同。
调用此函数后,调用者将负责先前由 String
管理的内存。
唯一的方法是使用 from_raw_parts
函数将裸指针,长度和容量转换回 String
,从而允许析构函数执行清除操作。
Examples
#![feature(vec_into_raw_parts)]
let s = String::from("hello");
let (ptr, len, cap) = s.into_raw_parts();
let rebuilt = unsafe { String::from_raw_parts(ptr, len, cap) };
assert_eq!(rebuilt, "hello");
Runsourcepub unsafe fn from_raw_parts(
buf: *mut u8,
length: usize,
capacity: usize
) -> String
pub unsafe fn from_raw_parts( buf: *mut u8, length: usize, capacity: usize ) -> String
根据长度,容量和指针创建一个新的 String
。
Safety
这是非常不安全的,因为没有检查的不变量的数量:
buf
处的内存需要由标准库使用的同一分配器预先分配,并且需要精确对齐 1.length
需要小于或等于capacity
。capacity
需要是正确的值。buf
的前length
字节必须为有效的 UTF-8。
违反这些可能会导致一些问题,比如破坏分配器的内部数据结构。
例如,从指向包含 UTF-8 的 C char
数组的指针构建 String
通常不安全,除非您确定该数组最初是由 Rust 标准库的分配器分配的。
buf
的所有权有效地转移到 String
,然后 String
可以随意释放,重新分配或更改指针所指向的内存的内容。
调用此函数后,请确保没有其他任何东西使用该指针。
Examples
基本用法:
use std::mem;
unsafe {
let s = String::from("hello");
// 防止自动丢弃字符串的数据
let mut s = mem::ManuallyDrop::new(s);
let ptr = s.as_mut_ptr();
let len = s.len();
let capacity = s.capacity();
let s = String::from_raw_parts(ptr, len, capacity);
assert_eq!(String::from("hello"), s);
}
Runsourcepub unsafe fn from_utf8_unchecked(bytes: Vec<u8>) -> String
pub unsafe fn from_utf8_unchecked(bytes: Vec<u8>) -> String
将字节的 vector 转换为 String
,而无需检查字符串是否包含有效的 UTF-8。
有关更多详细信息,请参见安全版本 from_utf8
。
Safety
此函数不安全,因为它不检查传递给它的字节是否为有效的 UTF-8。
如果违反了此约束,则 String
的未来用户可能会导致内存不安全问题,因为标准库的其余部分都假定 String
是有效的 UTF-8。
Examples
基本用法:
// vector 中的一些字节
let sparkle_heart = vec![240, 159, 146, 150];
let sparkle_heart = unsafe {
String::from_utf8_unchecked(sparkle_heart)
};
assert_eq!("💖", sparkle_heart);
Runsourcepub fn into_bytes(self) -> Vec<u8>
pub fn into_bytes(self) -> Vec<u8>
1.7.0 · sourcepub fn as_mut_str(&mut self) -> &mut str
pub fn as_mut_str(&mut self) -> &mut str
sourcepub fn extend_from_within<R>(&mut self, src: R)where
R: RangeBounds<usize>,
🔬This is a nightly-only experimental API. (string_extend_from_within
#103806)
pub fn extend_from_within<R>(&mut self, src: R)where R: RangeBounds<usize>,
string_extend_from_within
#103806)将 src
范围内的元素复制到字符串的末尾。
Panics
如果起始点或结束点不在 char
边界上,或超出边界,就会出现 panic。
Examples
#![feature(string_extend_from_within)]
let mut string = String::from("abcde");
string.extend_from_within(2..);
assert_eq!(string, "abcdecde");
string.extend_from_within(..2);
assert_eq!(string, "abcdecdeab");
string.extend_from_within(4..8);
assert_eq!(string, "abcdecdeabecde");
Runsourcepub fn reserve(&mut self, additional: usize)
pub fn reserve(&mut self, additional: usize)
保留至少比当前长度多 additional
字节的容量。分配器可以保留更多空间来推测性地避免频繁分配。
调用 reserve
后,容量将大于或等于 self.len() + additional
。
如果容量已经足够,则不执行任何操作。
Panics
如果新容量溢出 usize
,就会出现 panics。
Examples
基本用法:
let mut s = String::new();
s.reserve(10);
assert!(s.capacity() >= 10);
Run这实际上可能不会增加容量:
let mut s = String::with_capacity(10);
s.push('a');
s.push('b');
// s 现在的长度为 2,容量至少为 10
let capacity = s.capacity();
assert_eq!(2, s.len());
assert!(capacity >= 10);
// 因为我们已经至少有额外的 8 个容量,所以称这个...
s.reserve(8);
// ... 实际上并没有增加。
assert_eq!(capacity, s.capacity());
Runsourcepub fn reserve_exact(&mut self, additional: usize)
pub fn reserve_exact(&mut self, additional: usize)
保留至少比当前长度多 additional
字节的最小容量。
与 reserve
不同,这不会故意过度分配以推测性地避免频繁分配。
调用 reserve_exact
后,容量将大于或等于 self.len() + additional
。
如果容量已经足够,则不执行任何操作。
Panics
如果新容量溢出 usize
,就会出现 panics。
Examples
基本用法:
let mut s = String::new();
s.reserve_exact(10);
assert!(s.capacity() >= 10);
Run这实际上可能不会增加容量:
let mut s = String::with_capacity(10);
s.push('a');
s.push('b');
// s 现在的长度为 2,容量至少为 10
let capacity = s.capacity();
assert_eq!(2, s.len());
assert!(capacity >= 10);
// 因为我们已经至少有额外的 8 个容量,所以称这个...
s.reserve_exact(8);
// ... 实际上并没有增加。
assert_eq!(capacity, s.capacity());
Run1.57.0 · sourcepub fn try_reserve(&mut self, additional: usize) -> Result<(), TryReserveError>
pub fn try_reserve(&mut self, additional: usize) -> Result<(), TryReserveError>
尝试为至少比当前长度多 additional
字节的容量保留容量。
分配器可以保留更多空间来推测性地避免频繁分配。
调用 try_reserve
后,如果返回 Ok(())
,容量将大于等于 self.len() + additional
。
如果容量已经足够,则不执行任何操作。 即使发生错误,此方法也会保留内容。
Errors
如果容量溢出,或者分配器报告失败,则返回错误。
Examples
use std::collections::TryReserveError;
fn process_data(data: &str) -> Result<String, TryReserveError> {
let mut output = String::new();
// 预先保留内存,如果不能,则退出
output.try_reserve(data.len())?;
// 现在我们知道在我们复杂的工作中这不能 OOM
output.push_str(data);
Ok(output)
}
Run1.57.0 · sourcepub fn try_reserve_exact(
&mut self,
additional: usize
) -> Result<(), TryReserveError>
pub fn try_reserve_exact( &mut self, additional: usize ) -> Result<(), TryReserveError>
尝试为至少比当前长度多 additional
字节的最小容量保留。
与 try_reserve
不同,这不会故意过度分配以推测性地避免频繁分配。
调用 try_reserve_exact
后,如果返回 Ok(())
,则容量将大于或等于 self.len() + additional
。
如果容量已经足够,则不执行任何操作。
请注意,分配器可能会给集合提供比其请求更多的空间。
因此,不能依靠容量来精确地最小化。
如果希望将来插入,则首选 try_reserve
。
Errors
如果容量溢出,或者分配器报告失败,则返回错误。
Examples
use std::collections::TryReserveError;
fn process_data(data: &str) -> Result<String, TryReserveError> {
let mut output = String::new();
// 预先保留内存,如果不能,则退出
output.try_reserve_exact(data.len())?;
// 现在我们知道在我们复杂的工作中这不能 OOM
output.push_str(data);
Ok(output)
}
Runsourcepub fn shrink_to_fit(&mut self)
pub fn shrink_to_fit(&mut self)
sourcepub fn remove_matches<'a, P>(&'a mut self, pat: P)where
P: for<'x> Pattern<'x>,
🔬This is a nightly-only experimental API. (string_remove_matches
#72826)
pub fn remove_matches<'a, P>(&'a mut self, pat: P)where P: for<'x> Pattern<'x>,
string_remove_matches
#72826)删除 String
中所有模式 pat
的匹配项。
Examples
#![feature(string_remove_matches)]
let mut s = String::from("Trees are not green, the sky is not blue.");
s.remove_matches("not ");
assert_eq!("Trees are green, the sky is blue.", s);
Run匹配项将被检测并迭代删除,因此在样式重叠的情况下,仅第一个样式将被删除:
#![feature(string_remove_matches)]
let mut s = String::from("banana");
s.remove_matches("ana");
assert_eq!("bna", s);
Run1.26.0 · sourcepub fn retain<F>(&mut self, f: F)where
F: FnMut(char) -> bool,
pub fn retain<F>(&mut self, f: F)where F: FnMut(char) -> bool,
仅保留谓词指定的字符。
换句话说,删除所有字符 c
,以使 f(c)
返回 false
。
此方法在原地运行,以原始顺序恰好一次访问每个字符,并保留保留字符的顺序。
Examples
let mut s = String::from("f_o_ob_ar");
s.retain(|c| c != '_');
assert_eq!(s, "foobar");
Run由于按原始顺序仅对元素进行过一次访问,因此可以使用外部状态来确定要保留哪些元素。
let mut s = String::from("abcde");
let keep = [false, true, true, false, true];
let mut iter = keep.iter();
s.retain(|_| *iter.next().unwrap());
assert_eq!(s, "bce");
Run1.16.0 · sourcepub fn insert_str(&mut self, idx: usize, string: &str)
pub fn insert_str(&mut self, idx: usize, string: &str)
sourcepub unsafe fn as_mut_vec(&mut self) -> &mut Vec<u8>
pub unsafe fn as_mut_vec(&mut self) -> &mut Vec<u8>
返回此 String
的内容的可变引用。
Safety
这个函数是不安全的,因为返回的 &mut Vec
允许写入无效的 UTF-8 字节。
如果违反此约束,则在丢弃 &mut Vec
之后使用原始 String
可能会违反内存安全,因为标准库的其余部分假定 String
是有效的 UTF-8。
Examples
基本用法:
let mut s = String::from("hello");
unsafe {
let vec = s.as_mut_vec();
assert_eq!(&[104, 101, 108, 108, 111][..], &vec[..]);
vec.reverse();
}
assert_eq!(s, "olleh");
Run1.16.0 · sourcepub fn split_off(&mut self, at: usize) -> String
pub fn split_off(&mut self, at: usize) -> String
在给定的字节索引处将字符串拆分为两个。
返回新分配的 String
。
self
包含字节 [0, at)
,返回的 String
包含字节 [at, len)
。
at
必须位于 UTF-8 代码点的边界上。
请注意,self
的容量不会改变。
Panics
如果 at
不在 UTF-8
代码点边界上,或者它超出字符串的最后一个代码点,就会出现 panics。
Examples
let mut hello = String::from("Hello, World!");
let world = hello.split_off(7);
assert_eq!(hello, "Hello, ");
assert_eq!(world, "World!");
Run1.6.0 · sourcepub fn drain<R>(&mut self, range: R) -> Drain<'_> ⓘwhere
R: RangeBounds<usize>,
pub fn drain<R>(&mut self, range: R) -> Drain<'_> ⓘwhere R: RangeBounds<usize>,
从字符串中批量删除指定范围,并以迭代器的形式返回所有删除的字符。
返回的迭代器在字符串上保留一个可变借用以优化其实现。
Panics
如果起始点或结束点不在 char
边界上,或超出边界,就会出现 panic。
Leaking
如果返回的迭代器离开作用域而没有被丢弃 (例如,由于 core::mem::forget
),则字符串可能仍包含任何耗尽字符的副本,或者可能任意丢失字符,包括范围外的字符。
Examples
基本用法:
let mut s = String::from("α is alpha, β is beta");
let beta_offset = s.find('β').unwrap_or(s.len());
// 删除范围直到字符串中的 β
let t: String = s.drain(..beta_offset).collect();
assert_eq!(t, "α is alpha, ");
assert_eq!(s, "β is beta");
// 全范围清除字符串,就像 `clear()` 一样
s.drain(..);
assert_eq!(s, "");
Run1.27.0 · sourcepub fn replace_range<R>(&mut self, range: R, replace_with: &str)where
R: RangeBounds<usize>,
pub fn replace_range<R>(&mut self, range: R, replace_with: &str)where R: RangeBounds<usize>,
删除字符串中的指定范围,并将其替换为给定的字符串。 给定的字符串不必与范围相同。
Panics
如果起始点或结束点不在 char
边界上,或超出边界,就会出现 panic。
Examples
基本用法:
let mut s = String::from("α is alpha, β is beta");
let beta_offset = s.find('β').unwrap_or(s.len());
// 替换范围直到字符串中的 β
s.replace_range(..beta_offset, "Α is capital alpha; ");
assert_eq!(s, "Α is capital alpha; β is beta");
Run1.4.0 · sourcepub fn into_boxed_str(self) -> Box<str>
pub fn into_boxed_str(self) -> Box<str>
Methods from Deref<Target = str>§
sourcepub fn replace<'a, P: Pattern<'a>>(&'a self, from: P, to: &str) -> String
pub fn replace<'a, P: Pattern<'a>>(&'a self, from: P, to: &str) -> String
用另一个字符串替换模式的所有匹配项。
replace
创建一个新的 String
,并将此字符串切片中的数据复制到其中。
这样做时,它将尝试查找某个模式的匹配项。
如果找到,则将其替换为替换字符串切片。
Examples
基本用法:
let s = "this is old";
assert_eq!("this is new", s.replace("old", "new"));
assert_eq!("than an old", s.replace("is", "an"));
Run当模式不匹配时,它将此字符串切片作为 String
返回:
let s = "this is old";
assert_eq!(s, s.replace("cookie monster", "little lamb"));
Run1.16.0 · sourcepub fn replacen<'a, P: Pattern<'a>>(
&'a self,
pat: P,
to: &str,
count: usize
) -> String
pub fn replacen<'a, P: Pattern<'a>>( &'a self, pat: P, to: &str, count: usize ) -> String
用另一个字符串替换模式的前 N 个匹配项。
replacen
创建一个新的 String
,并将此字符串切片中的数据复制到其中。
这样做时,它将尝试查找某个模式的匹配项。
如果找到任何内容,则最多 count
次将它们替换为替换字符串切片。
Examples
基本用法:
let s = "foo foo 123 foo";
assert_eq!("new new 123 foo", s.replacen("foo", "new", 2));
assert_eq!("faa fao 123 foo", s.replacen('o', "a", 3));
assert_eq!("foo foo new23 foo", s.replacen(char::is_numeric, "new", 1));
Run当模式不匹配时,它将此字符串切片作为 String
返回:
let s = "this is old";
assert_eq!(s, s.replacen("cookie monster", "little lamb", 10));
Run1.2.0 · sourcepub fn to_lowercase(&self) -> String
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());
Run1.2.0 · sourcepub fn to_uppercase(&self) -> String
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());
Run1.23.0 · sourcepub fn to_ascii_uppercase(&self) -> String
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());
Run1.23.0 · sourcepub fn to_ascii_lowercase(&self) -> String
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());
Run1.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);
Runsourcepub fn as_ptr(&self) -> *const u8
pub 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<I>(&self, i: I) -> Option<&<I as SliceIndex<str>>::Output>where
I: SliceIndex<str>,
pub fn get<I>(&self, i: I) -> Option<&<I as SliceIndex<str>>::Output>where I: SliceIndex<str>,
1.20.0 · sourcepub fn get_mut<I>(
&mut self,
i: I
) -> Option<&mut <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>,
返回 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>(&self, i: I) -> &<I as SliceIndex<str>>::Outputwhere
I: SliceIndex<str>,
pub unsafe fn get_unchecked<I>(&self, i: I) -> &<I as SliceIndex<str>>::Outputwhere I: SliceIndex<str>,
返回未经检查的 str
子切片。
这是索引 str
的未经检查的替代方法。
Safety
此函数的调用者有责任满足以下先决条件:
- 起始索引不得超过结束索引;
- 索引必须在原始切片的范围内;
- 索引必须位于 UTF-8 序列边界上。
否则,返回的字符串切片可能会引用无效的内存或违反 str
类型传达的不变量。
Examples
let v = "🗻∈🌏";
unsafe {
assert_eq!("🗻", v.get_unchecked(0..4));
assert_eq!("∈", v.get_unchecked(4..7));
assert_eq!("🌏", v.get_unchecked(7..11));
}
Run1.20.0 · sourcepub unsafe fn get_unchecked_mut<I>(
&mut self,
i: I
) -> &mut <I as SliceIndex<str>>::Outputwhere
I: SliceIndex<str>,
pub unsafe fn get_unchecked_mut<I>( &mut self, i: I ) -> &mut <I as SliceIndex<str>>::Outputwhere I: SliceIndex<str>,
返回 str
的可变,未经检查的子切片。
这是索引 str
的未经检查的替代方法。
Safety
此函数的调用者有责任满足以下先决条件:
- 起始索引不得超过结束索引;
- 索引必须在原始切片的范围内;
- 索引必须位于 UTF-8 序列边界上。
否则,返回的字符串切片可能会引用无效的内存或违反 str
类型传达的不变量。
Examples
let mut v = String::from("🗻∈🌏");
unsafe {
assert_eq!("🗻", v.get_unchecked_mut(0..4));
assert_eq!("∈", v.get_unchecked_mut(4..7));
assert_eq!("🌏", v.get_unchecked_mut(7..11));
}
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>(&'a self, pat: P) -> boolwhere
P: Pattern<'a>,
pub fn starts_with<'a, P>(&'a self, pat: P) -> boolwhere P: Pattern<'a>,
sourcepub fn ends_with<'a, P>(&'a self, pat: P) -> boolwhere
P: Pattern<'a>,
<P as Pattern<'a>>::Searcher: ReverseSearcher<'a>,
pub fn ends_with<'a, P>(&'a self, pat: P) -> boolwhere P: Pattern<'a>, <P as Pattern<'a>>::Searcher: ReverseSearcher<'a>,
sourcepub fn find<'a, P>(&'a self, pat: P) -> Option<usize>where
P: Pattern<'a>,
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);
Runsourcepub fn rfind<'a, P>(&'a self, pat: P) -> Option<usize>where
P: Pattern<'a>,
<P as Pattern<'a>>::Searcher: ReverseSearcher<'a>,
pub fn rfind<'a, P>(&'a self, pat: P) -> Option<usize>where P: Pattern<'a>, <P as Pattern<'a>>::Searcher: ReverseSearcher<'a>,
返回此字符串切片中模式的最后一个匹配项的第一个字符的字节索引。
如果模式不匹配,则返回 None
。
模式 可以是 &str
,char
,char
的切片,也可以是确定字符是否匹配的函数或闭包。
Examples
简单模式:
let s = "Löwe 老虎 Léopard Gepardi";
assert_eq!(s.rfind('L'), Some(13));
assert_eq!(s.rfind('é'), Some(14));
assert_eq!(s.rfind("pard"), Some(24));
Run闭包的更复杂模式:
let s = "Löwe 老虎 Léopard";
assert_eq!(s.rfind(char::is_whitespace), Some(12));
assert_eq!(s.rfind(char::is_lowercase), Some(20));
Run找不到模式:
let s = "Löwe 老虎 Léopard";
let x: &[_] = &['1', '2'];
assert_eq!(s.rfind(x), None);
Runsourcepub fn split<'a, P>(&'a self, pat: P) -> Split<'a, P> ⓘwhere
P: Pattern<'a>,
pub fn split<'a, P>(&'a self, pat: P) -> Split<'a, P> ⓘwhere P: Pattern<'a>,
在此字符串切片的子字符串上进行迭代的迭代器,该子字符串由模式匹配的字符分隔。
模式 可以是 &str
,char
,char
的切片,也可以是确定字符是否匹配的函数或闭包。
迭代器行为
如果模式允许反向搜索且 forward/reverse 搜索产生相同的元素,则返回的迭代器将为 DoubleEndedIterator
。
例如,对于 char
,这是正确的,但对于 &str
,则不是。
如果模式允许反向搜索,但其结果可能与正向搜索不同,则可以使用 rsplit
方法。
Examples
简单模式:
let v: Vec<&str> = "Mary had a little lamb".split(' ').collect();
assert_eq!(v, ["Mary", "had", "a", "little", "lamb"]);
let v: Vec<&str> = "".split('X').collect();
assert_eq!(v, [""]);
let v: Vec<&str> = "lionXXtigerXleopard".split('X').collect();
assert_eq!(v, ["lion", "", "tiger", "leopard"]);
let v: Vec<&str> = "lion::tiger::leopard".split("::").collect();
assert_eq!(v, ["lion", "tiger", "leopard"]);
let v: Vec<&str> = "abc1def2ghi".split(char::is_numeric).collect();
assert_eq!(v, ["abc", "def", "ghi"]);
let v: Vec<&str> = "lionXtigerXleopard".split(char::is_uppercase).collect();
assert_eq!(v, ["lion", "tiger", "leopard"]);
Run如果模式是一片字符,请在每次出现任何字符时进行分割:
let v: Vec<&str> = "2020-11-03 23:59".split(&['-', ' ', ':', '@'][..]).collect();
assert_eq!(v, ["2020", "11", "03", "23", "59"]);
Run使用闭包的更复杂的模式:
let v: Vec<&str> = "abc1defXghi".split(|c| c == '1' || c == 'X').collect();
assert_eq!(v, ["abc", "def", "ghi"]);
Run如果一个字符串包含多个连续的分隔符,您将在输出中得到空字符串:
let x = "||||a||b|c".to_string();
let d: Vec<_> = x.split('|').collect();
assert_eq!(d, &["", "", "", "", "a", "", "b", "c"]);
Run连续的分隔符由空字符串分隔。
let x = "(///)".to_string();
let d: Vec<_> = x.split('/').collect();
assert_eq!(d, &["(", "", "", ")"]);
Run字符串开头或结尾的分隔符与空字符串相邻。
let d: Vec<_> = "010".split("0").collect();
assert_eq!(d, &["", "1", ""]);
Run当空字符串用作分隔符时,它将字符串中的每个字符以及字符串的开头和结尾分隔开。
let f: Vec<_> = "rust".split("").collect();
assert_eq!(f, &["", "r", "u", "s", "t", ""]);
Run当使用空格作为分隔符时,连续的分隔符可能会导致令人惊讶的行为。这段代码是正确的:
let x = " a b c".to_string();
let d: Vec<_> = x.split(' ').collect();
assert_eq!(d, &["", "", "", "", "a", "", "b", "c"]);
Run它确实不会给您:
为此行为使用 split_whitespace
。
1.51.0 · sourcepub fn split_inclusive<'a, P>(&'a self, pat: P) -> SplitInclusive<'a, P> ⓘwhere
P: Pattern<'a>,
pub fn split_inclusive<'a, P>(&'a self, pat: P) -> SplitInclusive<'a, P> ⓘwhere P: Pattern<'a>,
在此字符串切片的子字符串上进行迭代的迭代器,该子字符串由模式匹配的字符分隔。
与 split
产生的迭代器的不同之处在于 split_inclusive
将匹配的部分保留为子字符串的终止符。
模式 可以是 &str
,char
,char
的切片,也可以是确定字符是否匹配的函数或闭包。
Examples
let v: Vec<&str> = "Mary had a little lamb\nlittle lamb\nlittle lamb."
.split_inclusive('\n').collect();
assert_eq!(v, ["Mary had a little lamb\n", "little lamb\n", "little lamb."]);
Run如果字符串的最后一个元素匹配,则该元素将被视为前一个子字符串的终止符。 该子字符串将是迭代器返回的最后一个项。
let v: Vec<&str> = "Mary had a little lamb\nlittle lamb\nlittle lamb.\n"
.split_inclusive('\n').collect();
assert_eq!(v, ["Mary had a little lamb\n", "little lamb\n", "little lamb.\n"]);
Runsourcepub fn rsplit<'a, P>(&'a self, pat: P) -> RSplit<'a, P> ⓘwhere
P: Pattern<'a>,
<P as Pattern<'a>>::Searcher: ReverseSearcher<'a>,
pub fn rsplit<'a, P>(&'a self, pat: P) -> RSplit<'a, P> ⓘwhere P: Pattern<'a>, <P as Pattern<'a>>::Searcher: ReverseSearcher<'a>,
给定字符串切片的子字符串上的迭代器,该迭代器由与模式匹配的字符分隔,并以相反的顺序产生。
模式 可以是 &str
,char
,char
的切片,也可以是确定字符是否匹配的函数或闭包。
迭代器行为
返回的迭代器要求模式支持反向搜索,如果 forward/reverse 搜索产生相同的元素,它将是 DoubleEndedIterator
。
为了从正面进行迭代,可以使用 split
方法。
Examples
简单模式:
let v: Vec<&str> = "Mary had a little lamb".rsplit(' ').collect();
assert_eq!(v, ["lamb", "little", "a", "had", "Mary"]);
let v: Vec<&str> = "".rsplit('X').collect();
assert_eq!(v, [""]);
let v: Vec<&str> = "lionXXtigerXleopard".rsplit('X').collect();
assert_eq!(v, ["leopard", "tiger", "", "lion"]);
let v: Vec<&str> = "lion::tiger::leopard".rsplit("::").collect();
assert_eq!(v, ["leopard", "tiger", "lion"]);
Run使用闭包的更复杂的模式:
let v: Vec<&str> = "abc1defXghi".rsplit(|c| c == '1' || c == 'X').collect();
assert_eq!(v, ["ghi", "def", "abc"]);
Runsourcepub fn split_terminator<'a, P>(&'a self, pat: P) -> SplitTerminator<'a, P> ⓘwhere
P: Pattern<'a>,
pub fn split_terminator<'a, P>(&'a self, pat: P) -> SplitTerminator<'a, P> ⓘwhere P: Pattern<'a>,
给定字符串切片的子字符串上的迭代器,该子字符串由模式匹配的字符分隔。
模式 可以是 &str
,char
,char
的切片,也可以是确定字符是否匹配的函数或闭包。
等效于 split
,不同之处在于尾随的子字符串为空时将被跳过。
此方法可用于 terminated 的字符串数据,而不是用于模式的 separated 的字符串数据。
迭代器行为
如果模式允许反向搜索且 forward/reverse 搜索产生相同的元素,则返回的迭代器将为 DoubleEndedIterator
。
例如,对于 char
,这是正确的,但对于 &str
,则不是。
如果模式允许反向搜索,但其结果可能与正向搜索不同,则可以使用 rsplit_terminator
方法。
Examples
基本用法:
let v: Vec<&str> = "A.B.".split_terminator('.').collect();
assert_eq!(v, ["A", "B"]);
let v: Vec<&str> = "A..B..".split_terminator(".").collect();
assert_eq!(v, ["A", "", "B", ""]);
let v: Vec<&str> = "A.B:C.D".split_terminator(&['.', ':'][..]).collect();
assert_eq!(v, ["A", "B", "C", "D"]);
Runsourcepub fn rsplit_terminator<'a, P>(&'a self, pat: P) -> RSplitTerminator<'a, P> ⓘwhere
P: Pattern<'a>,
<P as Pattern<'a>>::Searcher: ReverseSearcher<'a>,
pub fn rsplit_terminator<'a, P>(&'a self, pat: P) -> RSplitTerminator<'a, P> ⓘwhere P: Pattern<'a>, <P as Pattern<'a>>::Searcher: ReverseSearcher<'a>,
self
子字符串上的迭代器,该迭代器由与模式匹配的字符分隔,并以相反的顺序产生。
模式 可以是 &str
,char
,char
的切片,也可以是确定字符是否匹配的函数或闭包。
等效于 split
,不同之处在于尾随的子字符串为空时将被跳过。
此方法可用于 terminated 的字符串数据,而不是用于模式的 separated 的字符串数据。
迭代器行为
返回的迭代器要求模式支持反向搜索,如果 forward/reverse 搜索产生相同的元素,则它将是双头模式。
为了从正面进行迭代,可以使用 split_terminator
方法。
Examples
let v: Vec<&str> = "A.B.".rsplit_terminator('.').collect();
assert_eq!(v, ["B", "A"]);
let v: Vec<&str> = "A..B..".rsplit_terminator(".").collect();
assert_eq!(v, ["", "B", "", "A"]);
let v: Vec<&str> = "A.B:C.D".rsplit_terminator(&['.', ':'][..]).collect();
assert_eq!(v, ["D", "C", "B", "A"]);
Runsourcepub fn splitn<'a, P>(&'a self, n: usize, pat: P) -> SplitN<'a, P> ⓘwhere
P: Pattern<'a>,
pub fn splitn<'a, P>(&'a self, n: usize, pat: P) -> SplitN<'a, P> ⓘwhere P: Pattern<'a>,
给定字符串切片的子字符串上的迭代器 (由模式分隔),仅限于返回最多 n
项。
如果返回 n
子字符串,则最后一个子字符串 (第 n 个子字符串) 将包含字符串的其余部分。
模式 可以是 &str
,char
,char
的切片,也可以是确定字符是否匹配的函数或闭包。
迭代器行为
返回的迭代器不会是双头的,因为支持效率不高。
如果模式允许反向搜索,则可以使用 rsplitn
方法。
Examples
简单模式:
let v: Vec<&str> = "Mary had a little lambda".splitn(3, ' ').collect();
assert_eq!(v, ["Mary", "had", "a little lambda"]);
let v: Vec<&str> = "lionXXtigerXleopard".splitn(3, "X").collect();
assert_eq!(v, ["lion", "", "tigerXleopard"]);
let v: Vec<&str> = "abcXdef".splitn(1, 'X').collect();
assert_eq!(v, ["abcXdef"]);
let v: Vec<&str> = "".splitn(1, 'X').collect();
assert_eq!(v, [""]);
Run使用闭包的更复杂的模式:
let v: Vec<&str> = "abc1defXghi".splitn(2, |c| c == '1' || c == 'X').collect();
assert_eq!(v, ["abc", "defXghi"]);
Runsourcepub fn rsplitn<'a, P>(&'a self, n: usize, pat: P) -> RSplitN<'a, P> ⓘwhere
P: Pattern<'a>,
<P as Pattern<'a>>::Searcher: ReverseSearcher<'a>,
pub fn rsplitn<'a, P>(&'a self, n: usize, pat: P) -> RSplitN<'a, P> ⓘwhere P: Pattern<'a>, <P as Pattern<'a>>::Searcher: ReverseSearcher<'a>,
从字符串的末尾开始,在此字符串切片的子字符串上进行迭代的迭代器,由模式分隔,限制为最多返回 n
项。
如果返回 n
子字符串,则最后一个子字符串 (第 n 个子字符串) 将包含字符串的其余部分。
模式 可以是 &str
,char
,char
的切片,也可以是确定字符是否匹配的函数或闭包。
迭代器行为
返回的迭代器不会是双头的,因为支持效率不高。
要从正面拆分,可以使用 splitn
方法。
Examples
简单模式:
let v: Vec<&str> = "Mary had a little lamb".rsplitn(3, ' ').collect();
assert_eq!(v, ["lamb", "little", "Mary had a"]);
let v: Vec<&str> = "lionXXtigerXleopard".rsplitn(3, 'X').collect();
assert_eq!(v, ["leopard", "tiger", "lionX"]);
let v: Vec<&str> = "lion::tiger::leopard".rsplitn(2, "::").collect();
assert_eq!(v, ["leopard", "lion::tiger"]);
Run使用闭包的更复杂的模式:
let v: Vec<&str> = "abc1defXghi".rsplitn(2, |c| c == '1' || c == 'X').collect();
assert_eq!(v, ["ghi", "abc1def"]);
Run1.52.0 · sourcepub fn split_once<'a, P>(&'a self, delimiter: P) -> Option<(&'a str, &'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>,
1.52.0 · sourcepub 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 rsplit_once<'a, P>(&'a self, delimiter: P) -> Option<(&'a str, &'a str)>where P: Pattern<'a>, <P as Pattern<'a>>::Searcher: ReverseSearcher<'a>,
1.2.0 · sourcepub fn matches<'a, P>(&'a self, pat: P) -> Matches<'a, P> ⓘwhere
P: Pattern<'a>,
pub fn matches<'a, P>(&'a self, pat: P) -> Matches<'a, P> ⓘwhere P: Pattern<'a>,
给定字符串切片中某个模式的不相交匹配的迭代器。
模式 可以是 &str
,char
,char
的切片,也可以是确定字符是否匹配的函数或闭包。
迭代器行为
如果模式允许反向搜索且 forward/reverse 搜索产生相同的元素,则返回的迭代器将为 DoubleEndedIterator
。
例如,对于 char
,这是正确的,但对于 &str
,则不是。
如果模式允许反向搜索,但其结果可能与正向搜索不同,则可以使用 rmatches
方法。
Examples
基本用法:
let v: Vec<&str> = "abcXXXabcYYYabc".matches("abc").collect();
assert_eq!(v, ["abc", "abc", "abc"]);
let v: Vec<&str> = "1abc2abc3".matches(char::is_numeric).collect();
assert_eq!(v, ["1", "2", "3"]);
Run1.2.0 · sourcepub fn rmatches<'a, P>(&'a self, pat: P) -> RMatches<'a, P> ⓘwhere
P: Pattern<'a>,
<P as Pattern<'a>>::Searcher: ReverseSearcher<'a>,
pub fn rmatches<'a, P>(&'a self, pat: P) -> RMatches<'a, P> ⓘwhere P: Pattern<'a>, <P as Pattern<'a>>::Searcher: ReverseSearcher<'a>,
在此字符串切片中某个模式的不相交匹配项上进行迭代的迭代器,其生成顺序相反。
模式 可以是 &str
,char
,char
的切片,也可以是确定字符是否匹配的函数或闭包。
迭代器行为
返回的迭代器要求模式支持反向搜索,如果 forward/reverse 搜索产生相同的元素,它将是 DoubleEndedIterator
。
为了从正面进行迭代,可以使用 matches
方法。
Examples
基本用法:
let v: Vec<&str> = "abcXXXabcYYYabc".rmatches("abc").collect();
assert_eq!(v, ["abc", "abc", "abc"]);
let v: Vec<&str> = "1abc2abc3".rmatches(char::is_numeric).collect();
assert_eq!(v, ["3", "2", "1"]);
Run1.5.0 · sourcepub fn match_indices<'a, P>(&'a self, pat: P) -> MatchIndices<'a, P> ⓘwhere
P: Pattern<'a>,
pub fn match_indices<'a, P>(&'a self, pat: P) -> MatchIndices<'a, P> ⓘwhere P: Pattern<'a>,
对该字符串切片中某个模式的不相交匹配以及该匹配开始处的索引的迭代器。
对于 self
中重叠的 pat
匹配项,仅返回与第一个匹配项对应的索引。
模式 可以是 &str
,char
,char
的切片,也可以是确定字符是否匹配的函数或闭包。
迭代器行为
如果模式允许反向搜索且 forward/reverse 搜索产生相同的元素,则返回的迭代器将为 DoubleEndedIterator
。
例如,对于 char
,这是正确的,但对于 &str
,则不是。
如果模式允许反向搜索,但其结果可能与正向搜索不同,则可以使用 rmatch_indices
方法。
Examples
基本用法:
let v: Vec<_> = "abcXXXabcYYYabc".match_indices("abc").collect();
assert_eq!(v, [(0, "abc"), (6, "abc"), (12, "abc")]);
let v: Vec<_> = "1abcabc2".match_indices("abc").collect();
assert_eq!(v, [(1, "abc"), (4, "abc")]);
let v: Vec<_> = "ababa".match_indices("aba").collect();
assert_eq!(v, [(0, "aba")]); // 只有第一个 `aba`
Run1.5.0 · sourcepub fn rmatch_indices<'a, P>(&'a self, pat: P) -> RMatchIndices<'a, P> ⓘwhere
P: Pattern<'a>,
<P as Pattern<'a>>::Searcher: ReverseSearcher<'a>,
pub fn rmatch_indices<'a, P>(&'a self, pat: P) -> RMatchIndices<'a, P> ⓘwhere P: Pattern<'a>, <P as Pattern<'a>>::Searcher: ReverseSearcher<'a>,
self
中某个模式的不相交匹配项上的迭代器,以与匹配项索引相反的顺序产生。
对于 self
中的 pat
重叠的匹配项,仅返回与最后一个匹配项对应的索引。
模式 可以是 &str
,char
,char
的切片,也可以是确定字符是否匹配的函数或闭包。
迭代器行为
返回的迭代器要求模式支持反向搜索,如果 forward/reverse 搜索产生相同的元素,它将是 DoubleEndedIterator
。
为了从正面进行迭代,可以使用 match_indices
方法。
Examples
基本用法:
let v: Vec<_> = "abcXXXabcYYYabc".rmatch_indices("abc").collect();
assert_eq!(v, [(12, "abc"), (6, "abc"), (0, "abc")]);
let v: Vec<_> = "1abcabc2".rmatch_indices("abc").collect();
assert_eq!(v, [(4, "abc"), (1, "abc")]);
let v: Vec<_> = "ababa".rmatch_indices("aba").collect();
assert_eq!(v, [(2, "aba")]); // 只有最后的 `aba`
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>,
<P as Pattern<'a>>::Searcher: DoubleEndedSearcher<'a>,
pub fn trim_matches<'a, P>(&'a self, pat: P) -> &'a strwhere P: Pattern<'a>, <P as Pattern<'a>>::Searcher: DoubleEndedSearcher<'a>,
返回具有与重复删除的模式匹配的所有前缀和后缀的字符串切片。
模式 可以是 char
、char
的切片,也可以是确定字符是否匹配的函数或闭包。
Examples
简单模式:
assert_eq!("11foo1bar11".trim_matches('1'), "foo1bar");
assert_eq!("123foo1bar123".trim_matches(char::is_numeric), "foo1bar");
let x: &[_] = &['1', '2'];
assert_eq!("12foo1bar12".trim_matches(x), "foo1bar");
Run使用闭包的更复杂的模式:
assert_eq!("1foo1barXX".trim_matches(|c| c == '1' || c == 'X'), "foo1bar");
Run1.30.0 · sourcepub fn trim_start_matches<'a, P>(&'a self, pat: P) -> &'a strwhere
P: Pattern<'a>,
pub fn trim_start_matches<'a, P>(&'a self, pat: P) -> &'a strwhere P: Pattern<'a>,
返回字符串切片,该字符串切片的所有前缀都与重复删除的模式匹配。
模式 可以是 &str
,char
,char
的切片,也可以是确定字符是否匹配的函数或闭包。
文字方向性
字符串是字节序列。
start
在此上下文中表示该字节字符串的第一个位置; 对于从左到右的语言 (例如英语或俄语),这将是左侧; 对于从右到左的语言 (例如阿拉伯语或希伯来语),这将是右侧。
Examples
基本用法:
assert_eq!("11foo1bar11".trim_start_matches('1'), "foo1bar11");
assert_eq!("123foo1bar123".trim_start_matches(char::is_numeric), "foo1bar123");
let x: &[_] = &['1', '2'];
assert_eq!("12foo1bar12".trim_start_matches(x), "foo1bar12");
Run1.45.0 · sourcepub fn strip_prefix<'a, P>(&'a self, prefix: P) -> Option<&'a str>where
P: Pattern<'a>,
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"));
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>,
<P as Pattern<'a>>::Searcher: ReverseSearcher<'a>,
pub fn trim_end_matches<'a, P>(&'a self, pat: P) -> &'a strwhere P: Pattern<'a>, <P as Pattern<'a>>::Searcher: ReverseSearcher<'a>,
返回一个字符串切片,该字符串具有与重复删除的模式匹配的所有后缀。
模式 可以是 &str
,char
,char
的切片,也可以是确定字符是否匹配的函数或闭包。
文字方向性
字符串是字节序列。
end
在此上下文中表示该字节字符串的最后位置; 对于从左到右的语言 (例如英语或俄语),这将在右侧; 对于从右到左的语言 (例如阿拉伯语或希伯来语),将在左侧。
Examples
简单模式:
assert_eq!("11foo1bar11".trim_end_matches('1'), "11foo1bar");
assert_eq!("123foo1bar123".trim_end_matches(char::is_numeric), "123foo1bar");
let x: &[_] = &['1', '2'];
assert_eq!("12foo1bar12".trim_end_matches(x), "12foo1bar");
Run使用闭包的更复杂的模式:
assert_eq!("1fooX".trim_end_matches(|c| c == '1' || c == 'X'), "1foo");
Runsourcepub fn trim_left_matches<'a, P>(&'a self, pat: P) -> &'a strwhere
P: Pattern<'a>,
👎Deprecated since 1.33.0: superseded by trim_start_matches
pub fn trim_left_matches<'a, P>(&'a self, pat: P) -> &'a strwhere P: Pattern<'a>,
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>,
<P as 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>, <P as 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>(&self) -> Result<F, <F as FromStr>::Err>where
F: FromStr,
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());
Runsourcepub fn as_ascii(&self) -> Option<&[AsciiChar]>
🔬This is a nightly-only experimental API. (ascii_char
#110998)
pub fn as_ascii(&self) -> Option<&[AsciiChar]>
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 Add<&str> for String
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;
Run1.12.0 · source§impl AddAssign<&str> for String
impl AddAssign<&str> for String
实现用于追加到 String
的 +=
运算符。
这与 push_str
方法具有相同的行为。
source§fn add_assign(&mut self, other: &str)
fn add_assign(&mut self, other: &str)
+=
操作。 Read more1.36.0 · source§impl BorrowMut<str> for String
impl BorrowMut<str> for String
source§fn borrow_mut(&mut self) -> &mut str
fn borrow_mut(&mut self) -> &mut str
1.2.0 · source§impl<'a> Extend<&'a char> for String
impl<'a> Extend<&'a char> for String
source§fn extend_one(&mut self, c: &'a char)
fn extend_one(&mut self, c: &'a char)
extend_one
#72631)source§impl<'a> Extend<&'a str> for String
impl<'a> Extend<&'a str> for String
source§fn extend_one(&mut self, s: &'a str)
fn extend_one(&mut self, s: &'a str)
extend_one
#72631)1.45.0 · source§impl Extend<Box<str, Global>> for String
impl Extend<Box<str, Global>> for String
source§fn extend_one(&mut self, item: A)
fn extend_one(&mut self, item: A)
extend_one
#72631)1.19.0 · source§impl<'a> Extend<Cow<'a, str>> for String
impl<'a> Extend<Cow<'a, str>> for String
1.4.0 · source§impl Extend<String> for String
impl Extend<String> for String
source§fn extend_one(&mut self, s: String)
fn extend_one(&mut self, s: String)
extend_one
#72631)source§impl Extend<char> for String
impl Extend<char> for String
source§fn extend_one(&mut self, c: char)
fn extend_one(&mut self, c: char)
extend_one
#72631)1.6.0 · source§impl From<String> for Box<dyn Error>
impl From<String> for Box<dyn Error>
source§impl From<String> for Box<dyn Error + Send + Sync>
impl From<String> for Box<dyn Error + Send + Sync>
source§fn from(err: String) -> Box<dyn Error + Send + Sync>
fn from(err: String) -> Box<dyn Error + Send + Sync>
将 String
转换为 Dyn Error
+ Send
+ Sync
的 box。
Examples
use std::error::Error;
use std::mem;
let a_string_error = "a string error".to_string();
let a_boxed_error = Box::<dyn Error + Send + Sync>::from(a_string_error);
assert!(
mem::size_of::<Box<dyn Error + Send + Sync>>() == mem::size_of_val(&a_boxed_error))
Run1.17.0 · source§impl<'a> FromIterator<&'a char> for String
impl<'a> FromIterator<&'a char> for String
source§impl<'a> FromIterator<&'a str> for String
impl<'a> FromIterator<&'a str> for String
1.4.0 · source§impl FromIterator<String> for String
impl FromIterator<String> for String
source§impl FromIterator<char> for String
impl FromIterator<char> for String
source§impl PartialOrd<String> for String
impl PartialOrd<String> for String
source§impl<'a, 'b> Pattern<'a> for &'b String
impl<'a, 'b> Pattern<'a> for &'b String
一个方便的 impl,委派给 &str
的 impl。
Examples
assert_eq!(String::from("Hello world").find("world"), Some(6));
Run§type Searcher = <&'b str as Pattern<'a>>::Searcher
type Searcher = <&'b str as Pattern<'a>>::Searcher
pattern
#27721)source§fn into_searcher(self, haystack: &'a str) -> <&'b str as Pattern<'a>>::Searcher
fn into_searcher(self, haystack: &'a str) -> <&'b str as Pattern<'a>>::Searcher
pattern
#27721)self
和 haystack
构造关联的搜索器以进行搜索。source§fn is_contained_in(self, haystack: &'a str) -> bool
fn is_contained_in(self, haystack: &'a str) -> bool
pattern
#27721)source§fn is_prefix_of(self, haystack: &'a str) -> bool
fn is_prefix_of(self, haystack: &'a str) -> bool
pattern
#27721)source§fn strip_prefix_of(self, haystack: &'a str) -> Option<&'a str>
fn strip_prefix_of(self, haystack: &'a str) -> Option<&'a str>
pattern
#27721)