如何基于Regex crate高效移除字符串末尾的字符/字节？

嘿，看你的代码和问题，你已经在用regex处理字符串开头的匹配了，但遇到了两个小麻烦：一是当前代码里的删除方法不对，二是想知道怎么高效移除字符串末尾的内容，还担心O(n)的性能开销对吧？我来一步步给你捋清楚。

首先先解决你当前的开头移除需求——你写的s.delete(0, cap.end())其实Rust的String根本没有这个方法，咱们换个正确的方式：

一、高效移除字符串开头匹配的部分 #

这里分两种场景：

1. 优先用切片（性能最优）
   如果你的业务场景允许返回字符串切片（&str）而不是修改原String，那这绝对是最高效的方式——切片只是引用原字符串的一部分，完全没有内存移动，性能是O(1)的：

use lazy_static::lazy_static;
use regex::Regex;

fn do_something(s: &str) {
    assert_eq!(s, "123");
}

fn func(s: &str) -> &str {
    lazy_static! {
        static ref RE: Regex = Regex::new(r"123").unwrap();
    }
    match RE.captures(s) {
        Some(cap) => {
            let matched = cap.get(0).unwrap();
            do_something(matched.as_str());
            &s[matched.end()..] // 直接返回切片，原字符串完全不动
        }
        None => panic!("Error"),
    }
}

fn main() {
    let s = String::from("123456");
    let result = func(&s);
    assert_eq!(result, "456");
}

2. 必须修改原String的情况
   如果一定要修改原String，可以用split_off方法——它会把字符串从指定索引处分割，返回前半部分，原字符串剩下的就是你要保留的内容。而且regex返回的end()是有效的UTF-8字节索引，完全不用担心非ASCII字符的问题：

use lazy_static::lazy_static;
use regex::Regex;

fn do_something(s: &str) {
    assert_eq!(s, "123");
}

fn func(s: &mut String) {
    lazy_static! {
        static ref RE: Regex = Regex::new(r"123").unwrap();
    }
    let cap = RE.captures(s.as_str())
        .and_then(|v| v.get(0))
        .expect("Error");
    
    do_something(cap.as_str());
    // 分割后，原字符串会变成从cap.end()开始的部分
    let _ = s.split_off(cap.end());
}

fn main() {
    let mut s = String::from("123456");
    func(&mut s);
    assert_eq!(s, "456");
}

这里要注意：split_off的性能是O(n)，因为需要把后面的字节往前移动——这是Rust中UTF-8字符串的特性决定的，毕竟字符串底层是字节数组，修改开头部分必然要移动数据，没法完全避免。但如果不是处理超大规模的字符串，这个开销其实可以接受。

二、高效移除字符串末尾的字符/字节 #

同样分两种情况处理：

1. 移除固定数量的字符
   因为UTF-8是变长编码，不能直接按字节截断（会损坏非ASCII字符），所以得先找到倒数第N个字符的起始字节索引，再用truncate截断——truncate本身是O(1)的，只是修改数组长度，不用移动数据：

fn remove_last_chars(s: &mut String, count: usize) {
    // 找到倒数第count个字符的起始字节位置
    let new_end = s.char_indices().nth_back(count).map_or(0, |(index, _)| index);
    s.truncate(new_end);
}

// 用法示例
fn main() {
    let mut s = String::from("Hello 世界");
    remove_last_chars(&mut s, 2); // 移除最后2个字符
    assert_eq!(s, "Hello ");
}

这里char_indices().nth_back(count)是O(n)的，因为要从后往前遍历找字符边界，但这是处理UTF-8字符的必要步骤。

2. 移除末尾匹配的正则模式
   如果要移除的是末尾符合某个模式的内容，继续用regex就好，匹配到末尾的内容后，截断到匹配的起始位置就行：

use lazy_static::lazy_static;
use regex::Regex;

lazy_static! {
    static ref END_PATTERN: Regex = Regex::new(r"xyz$").unwrap(); // 匹配末尾的xyz
}

fn remove_end_pattern(s: &mut String) {
    if let Some(cap) = END_PATTERN.captures(s) {
        let matched = cap.get(0).unwrap();
        s.truncate(matched.start()); // 截断到匹配内容的起始位置
    }
}

// 用法示例
fn main() {
    let mut s = String::from("abcxyz");
    remove_end_pattern(&mut s);
    assert_eq!(s, "abc");
}

这个方式的性能主要取决于regex的匹配效率，而truncate还是O(1)的操作，同样不用担心非ASCII字符的问题，因为regex会正确处理UTF-8边界。

最后说下性能顾虑 #

你提到remove方法是O(n)，其实Rust中大多数修改字符串开头/中间的操作都是O(n)，因为要移动底层字节。但如果能切换到切片的思路，就能把性能降到O(1)——这是最推荐的优化方式。如果必须修改原字符串，那O(n)的开销在大多数场景下都是可以接受的，除非你在处理GB级别的超大字符串。

备注：内容来源于stack exchange，提问作者饕餮饗食