字符串切片原理 ​

什么是字符串切片 ​

字符串切片是对字符串中一段连续字节序列的引用。它的类型是 &str,和字符串字面量的类型一样。字符串切片不拥有数据,只是"指向"原始字符串中某个范围的内容。

从 String 或 &str 中截取一部分得到的就是字符串切片。切片的范围是按字节位置(不是字符位置)指定的。

rust
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 是一个胖指针,由两部分组成:

  • 指向字节数据起始位置的指针
  • 切片覆盖的字节长度
rust
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 字节数举例
ASCII1 字节A, z, 0, !
拉丁扩展/希腊字母2 字节é, ñ, α
中日韩文字3 字节中, 好, 東
Emoji/罕见符号4 字节🦀, 😀, 𝄞
rust
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,那怎么安全地按字符数量截取字符串呢?

rust
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);
    }
}

切片与所有权 ​

字符串切片是借用,不拥有数据。这意味着原始字符串在切片存活期间不能被修改或释放。

rust
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);
}

基本示例 ​

实现一个提取字符串中第一个单词的函数:

rust
// 返回字符串中的第一个单词(以空格分隔)
// 返回的是原始字符串的切片,不复制数据
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() 确保不会切到字符中间。