Rust字符串多次替换表达式时的借用冲突问题求解

我有一个无空格的逻辑表达式字符串，示例为"((a<=b)||(c&&(d==a))"。需要逐步找出所有可求解的部分，将其替换为"[i]"（i随每次替换递增），预期转换过程为：
"((a<=b)||(c&&(d==a))" ⇒ "([0]||(c&&[1]))" ⇒ "([0]||[2])" ⇒ "[3]"
同时需要捕获每个被替换部分的操作符和操作数。

我编写了如下Rust函数，通过正则表达式EXPR_RE查找和捕获目标部分：

fn my_replace(in_str: &str) -> ([&str; 64], [[&str; 2]; 64]) {
    let mut operators: [&str; 64] = [""; 64];
    let mut operands: [[&str; 2]; 64] = [[""; 2]; 64];

    lazy_static! {
        static ref EXPR_RE: Regex =
            Regex::new(r"(\[?[A-Za-z0-9]+\]?)(==|&&|\|\||<=|!)(\[?[A-Za-z0-9]+\]?)").unwrap();
    }
    let mut i: usize = 0;
    let mut repl_line: String = in_str.to_string();
    loop {
        match EXPR_RE.is_match(&repl_line) {
            true => {
                for (_, [var_left, operand, var_right]) in
                    EXPR_RE.captures_iter(&repl_line).map(|c| c.extract())
                {
                    operands[i] = [var_left, var_right];
                    operators[i] = operand;
                    let orig_str = format!("({}{}{})", var_left, operand, var_right);
                    let repl_str = format!("[{}]", i);
                    repl_line = repl_line.replace(&orig_str, &repl_str);
                    i += 1;
                }
            }
            false => {
                break;
            }
        }
    }

    return (operators, operands);
}

问题在于，在执行替换的for循环中，由于EXPR_RE.captures_iter(&repl_line)已借用repl_line，导致无法对repl_line进行赋值操作，不知该如何解决这一问题。

我知道单遍替换可以正常工作，测试时的单遍替换函数如下：

fn _temp(in_str: &str) -> String {
    let mut operators: [&str; 64] = [""; 64];
    let mut operands: [[&str; 2]; 64] = [[""; 2]; 64];

    lazy_static! {
        static ref EXPR_RE: Regex =
            Regex::new(r"(\[?[A-Za-z0-9]+\]?)(==|&&|\|\||<=|!)(\[?[A-Za-z0-9]+\]?)").unwrap();
    }

    let mut i: usize = 0;
    let mut repl_line: String = in_str.to_string();
    for (_, [var_left, operand, var_right]) in EXPR_RE.captures_iter(in_str).map(|c| c.extract()) {
        operands[i] = [var_left, var_right];
        operators[i] = operand;
        let orig_str = format!("({}{}{})", var_left, operand, var_right);
        let repl_str = format!("[{}]", i);
        repl_line = repl_line.replace(&orig_str, &repl_str);
        i += 1;
    }

    return repl_line;
}

该函数可完成第一步替换，但不知如何实现支持多遍替换的完整函数，恳请提供帮助。

核心问题解决思路 #

你遇到的借用冲突，本质是captures_iter持有repl_line的不可变引用时，无法同时对repl_line进行可变赋值。解决办法是先收集所有当前轮次的匹配结果，再批量执行替换操作，避免迭代与修改同时进行。

另外，原正则表达式存在两个关键问题：

• 没有匹配被括号包裹的完整目标表达式（你的替换对象是(a<=b)这类带括号的片段）
• 单目运算符!的匹配逻辑错误（!只有单个操作数，原正则强行匹配左右两个操作数会出错）

修改后的完整代码 #

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

fn my_replace(in_str: &str) -> ([String; 64], [[String; 2]; 64]) {
    // 改用String存储，避免生命周期问题
    let mut operators: [String; 64] = Default::default();
    let mut operands: [[String; 2]; 64] = Default::default();

    lazy_static! {
        // 合并匹配双目和单目运算符的带括号表达式
        static ref EXPR_RE: Regex = Regex::new(
            r"\((!(\[?[A-Za-z0-9]+\]?)|(\[?[A-Za-z0-9]+\]?)(==|&&|\|\||<=)(\[?[A-Za-z0-9]+\]?))\)"
        ).unwrap();
    }

    let mut i: usize = 0;
    let mut repl_line: String = in_str.to_string();

    loop {
        // 先收集当前所有匹配项，避免迭代时修改repl_line导致借用冲突
        let matches: Vec<(String, String, [String; 2])> = EXPR_RE.captures_iter(&repl_line)
            .filter_map(|cap| {
                let full_match = cap[0].to_string();
                // 区分单目和双目运算符
                if let Some(op) = cap.get(1) {
                    if op.as_str().starts_with('!') {
                        // 单目运算符!
                        let operand = cap[2].to_string();
                        Some((full_match, "!".to_string(), [operand, String::new()]))
                    } else {
                        // 双目运算符
                        let left = cap[3].to_string();
                        let op = cap[4].to_string();
                        let right = cap[5].to_string();
                        Some((full_match, op, [left, right]))
                    }
                } else {
                    None
                }
            })
            .collect();

        if matches.is_empty() {
            break;
        }

        // 遍历收集到的匹配项，执行替换并记录操作符和操作数
        for (full_match, op, ops) in matches {
            operators[i] = op;
            operands[i] = ops;
            let repl_str = format!("[{}]", i);
            // 替换所有当前匹配的片段（注意：如果有重复匹配，replace会替换所有，符合需求）
            repl_line = repl_line.replace(&full_match, &repl_str);
            i += 1;
        }
    }

    (operators, operands)
}

// 测试示例
fn main() {
    let input = "((a<=b)||(c&&(d==a)))";
    let (operators, operands) = my_replace(input);
    
    println!("替换后的最终结果: [{}]", operators.iter().filter(|s| !s.is_empty()).count() - 1);
    println!("捕获的操作符:");
    for (idx, op) in operators.iter().enumerate() {
        if !op.is_empty() {
            println!("[{}]: {}", idx, op);
        }
    }
    println!("捕获的操作数:");
    for (idx, ops) in operands.iter().enumerate() {
        if !ops[0].is_empty() {
            println!("[{}]: {}, {}", idx, ops[0], ops[1]);
        }
    }
}

关键修改点说明 #

1. 解决借用冲突：

   • 每次循环先通过captures_iter收集所有匹配项到matches向量中，此时repl_line的不可变引用仅用于收集数据，收集完成后引用就释放了。
   • 后续遍历matches进行替换操作时，对repl_line的可变赋值不会再产生借用冲突。

2. 正则表达式修复：

   • 匹配被()包裹的完整表达式，确保替换的是(a<=b)这类目标片段。
   • 区分单目运算符!和双目运算符（==、&&、||、<=），分别处理操作数数量。

3. 生命周期优化：

   • 将返回值的&str改为String，避免原字符串生命周期限制导致的编译错误，因为原输入字符串的生命周期可能短于返回值的使用场景。

执行流程验证 #

对于输入"((a<=b)||(c&&(d==a)))"，执行流程如下：

1. 第一轮匹配到(a<=b)和(d==a)，替换为[0]和[1]，得到"([0]||(c&&[1]))"
2. 第二轮匹配到(c&&[1])，替换为[2]，得到"([0]||[2])"
3. 第三轮匹配到([0]||[2])，替换为[3]，得到"[3]"
4. 没有更多匹配项，循环结束

内容的提问来源于stack exchange，提问作者Patrik Holub