字符串切片原理
什么是字符串切片
字符串切片是对字符串中一段连续字节序列的引用。它的类型是 &str,和字符串字面量的类型一样。字符串切片不拥有数据,只是"指向"原始字符串中某个范围的内容。
从 String 或 &str 中截取一部分得到的就是字符串切片。切片的范围是按字节位置(不是字符位置)指定的。
fn main() {
let full = String::from("Hello, World!");
// 从 String 中取切片
let hello: &str = &full[0..5]; // "Hello"
let world: &str = &full[7..12]; // "World"
println!("{} - {}", hello, world);
// 字符串字面量本身就是切片
let literal: &str = "Hello, World!";
// 从字面量中取子切片
let sub: &str = &literal[0..5];
println!("{}", sub); // "Hello"
}字符串切片的内存结构
字符串切片 &str 是一个胖指针,由两部分组成:
- 指向字节数据起始位置的指针
- 切片覆盖的字节长度
fn main() {
let s = String::from("Hello, Rust!");
// 完整引用
let full: &str = &s;
// full 的指针指向 s 堆数据的第 0 个字节,长度 = 12
// 部分切片
let part: &str = &s[7..11];
// part 的指针指向 s 堆数据的第 7 个字节,长度 = 4
println!("完整:'{}',长度:{}", full, full.len()); // 12
println!("部分:'{}',长度:{}", part, part.len()); // 4
// 切片不复制数据,只是引用原始数据的不同区域
// full 和 part 都指向 s 在堆上的同一块内存
}UTF-8 编码与字节边界
Rust 的字符串使用 UTF-8 编码,不同字符占用的字节数不同。字符串切片的范围索引是按字节计算的,必须落在字符的边界上。
| 字符类型 | UTF-8 字节数 | 举例 |
|---|---|---|
| ASCII | 1 字节 | A, z, 0, ! |
| 拉丁扩展/希腊字母 | 2 字节 | é, ñ, α |
| 中日韩文字 | 3 字节 | 中, 好, 東 |
| Emoji/罕见符号 | 4 字节 | 🦀, 😀, 𝄞 |
fn main() {
let text = "Hello你好🦀";
// 查看每个字符的字节范围
let mut byte_pos = 0;
for ch in text.chars() {
let len = ch.len_utf8();
println!("'{}' -> 字节 {}..{} ({} 字节)",
ch, byte_pos, byte_pos + len, len);
byte_pos += len;
}
// 'H' -> 字节 0..1 (1 字节)
// 'e' -> 字节 1..2 (1 字节)
// 'l' -> 字节 2..3 (1 字节)
// 'l' -> 字节 3..4 (1 字节)
// 'o' -> 字节 4..5 (1 字节)
// '你' -> 字节 5..8 (3 字节)
// '好' -> 字节 8..11 (3 字节)
// '🦀' -> 字节 11..15 (4 字节)
// 合法的切片:在字符边界上
println!("{}", &text[0..5]); // "Hello"
println!("{}", &text[5..11]); // "你好"
// 非法的切片:切到字符中间
// println!("{}", &text[5..7]); // panic! 不在 char boundary 上
}安全地按字符切片
既然字节索引可能切到字符中间导致 panic,那怎么安全地按字符数量截取字符串呢?
fn main() {
let text = "Hello你好World🦀";
// 方法一:用 char_indices 找到字符的字节边界
fn safe_substr(s: &str, start_char: usize, end_char: usize) -> &str {
let mut indices = s.char_indices();
// 找到第 start_char 个字符的起始字节位置
let start_byte = if start_char == 0 {
0
} else {
match indices.nth(start_char - 1) {
Some((_, ch)) => {
// nth 已经消耗了前面的字符,当前位置加上当前字符的字节长度
// 重新计算
s.char_indices()
.nth(start_char)
.map(|(i, _)| i)
.unwrap_or(s.len())
}
None => s.len(),
}
};
// 更简洁的实现
let start_byte = s.char_indices()
.nth(start_char)
.map(|(i, _)| i)
.unwrap_or(s.len());
let end_byte = s.char_indices()
.nth(end_char)
.map(|(i, _)| i)
.unwrap_or(s.len());
&s[start_byte..end_byte]
}
// 取第 0-5 个字符
println!("{}", safe_substr(text, 0, 5)); // "Hello"
// 取第 5-7 个字符
println!("{}", safe_substr(text, 5, 7)); // "你好"
// 取第 7-12 个字符
println!("{}", safe_substr(text, 7, 12)); // "World"
// 方法二:先转成 Vec<char>,再转回来
let chars: Vec<char> = text.chars().collect();
let sub: String = chars[5..7].iter().collect();
println!("Vec<char> 方式:{}", sub); // "你好"
// 方法三:用 is_char_boundary 检查
let idx = 7;
if text.is_char_boundary(idx) {
println!("字节 {} 是字符边界", idx);
} else {
println!("字节 {} 不是字符边界", idx);
}
}切片与所有权
字符串切片是借用,不拥有数据。这意味着原始字符串在切片存活期间不能被修改或释放。
fn main() {
let mut s = String::from("hello world");
// 从 s 中取一个切片
let word = &s[0..5]; // 借用了 s
// 在 word 存活期间不能修改 s
// s.clear(); // 编译错误:cannot borrow `s` as mutable because it is also borrowed as immutable
println!("切片:{}", word); // word 在这里最后使用
// word 不再使用后,可以修改 s
s.clear();
println!("清空后:'{}'", s);
}基本示例
实现一个提取字符串中第一个单词的函数:
// 返回字符串中的第一个单词(以空格分隔)
// 返回的是原始字符串的切片,不复制数据
fn first_word(s: &str) -> &str {
let bytes = s.as_bytes();
for (i, &byte) in bytes.iter().enumerate() {
if byte == b' ' {
return &s[0..i];
}
}
// 没有空格,整个字符串就是一个单词
s
}
// 提取所有单词,返回切片的集合
fn all_words(s: &str) -> Vec<&str> {
s.split_whitespace().collect()
}
// 检查字符串是否是合法的标识符(字母开头,字母数字下划线组成)
fn is_valid_identifier(s: &str) -> bool {
if s.is_empty() {
return false;
}
let mut chars = s.chars();
// 第一个字符必须是字母或下划线
match chars.next() {
Some(c) if c.is_alphabetic() || c == '_' => {}
_ => return false,
}
// 后续字符可以是字母、数字或下划线
chars.all(|c| c.is_alphanumeric() || c == '_')
}
fn main() {
let sentence = "Hello World Rust Programming";
println!("第一个单词:{}", first_word(sentence));
println!("所有单词:{:?}", all_words(sentence));
// 也能传 String 的引用
let owned = String::from("Rust is great");
println!("第一个单词:{}", first_word(&owned));
// 标识符检查
let names = ["hello", "_count", "3abc", "my_var", "", "hello world"];
for name in &names {
println!("'{}' 是合法标识符:{}", name, is_valid_identifier(name));
}
}常见问题
问题一:为什么字符串切片用字节索引而不是字符索引?
因为 UTF-8 是变长编码,如果用字符索引,每次切片都需要从头扫描来找到第 n 个字符的字节位置,时间复杂度是 O(n)。字节索引是 O(1) 的直接操作。Rust 选择了暴露底层真相而不是隐藏性能陷阱。
问题二:切到字符中间会怎样?
程序会立即 panic,错误消息类似 byte index 7 is not a char boundary。Rust 不允许产生无效的 UTF-8 切片。可以用 s.is_char_boundary(n) 在切片前检查。
问题三:字符串切片和数组切片有什么关系?
&str 本质上就是 &[u8] 加上"保证是合法 UTF-8"的约束。&str 可以通过 .as_bytes() 得到 &[u8],反过来 &[u8] 通过 std::str::from_utf8() 可以尝试转成 &str(可能失败,如果不是合法 UTF-8)。
问题四:多个切片可以同时引用同一个字符串吗?
可以。多个不可变切片可以同时存在,它们都是不可变借用,互不冲突。但在有不可变切片存活期间,不能对原始字符串进行修改。
适用场景
- 零拷贝解析:解析 CSV、JSON、日志等文本时,返回原始数据的切片而不是复制
- 子字符串提取:从大字符串中取出感兴趣的部分
- 字符串搜索结果:
split、matches等方法返回的都是切片 - 函数返回值:返回输入字符串的一部分,避免复制
注意事项
- 切片的范围索引是字节位置,不是字符位置
- 切片范围必须落在 UTF-8 字符边界上,否则会 panic
- 用
is_char_boundary()检查一个字节位置是否在字符边界上 - 字符串切片是借用,原始字符串必须在切片使用期间保持有效
- 需要按字符数量截取时,用
char_indices()找到正确的字节位置 split_whitespace()、lines()、split()等方法返回的迭代器产出的元素都是&str切片- 从
&[u8]创建&str需要用std::str::from_utf8(),会验证 UTF-8 合法性
总结
字符串切片的本质是对一段 UTF-8 字节序列的胖指针引用(指针 + 长度)。切片的范围用字节位置指定,必须落在字符边界上。这个设计暴露了 UTF-8 变长编码的真相——不同字符占用 1-4 个字节,按字符索引是 O(n) 操作。字符串切片不复制数据,是零成本的引用,特别适合解析和提取文本的场景。操作切片时最需要注意的是字节边界问题:对纯 ASCII 文本不用担心,但对中文、emoji 等多字节字符,要用 char_indices() 或 is_char_boundary() 确保不会切到字符中间。