如何重构Rust代码以规避借用检查器限制？

尝试遵循DRY原则重构代码，将重复逻辑抽取为独立方法时，遇到Rust借用检查器报错：cannot borrow *self as immutable because it is also borrowed as mutable。常规重构方式失效，示例代码如下：

pub struct Foo {
    pub bar: Option<String>,
    pub baz: String,
}

impl Foo {
    pub fn first(&mut self) {
        match self.bar {
            None => {}
            Some(ref mut v) => {
                self.second(v);
                println!("{}", v);
            },
        }
    }

    pub fn second(&self, s: &mut String) {
        s.push_str(&self.baz);
    }
}

fn main() {
    let mut foo = Foo {
        bar: Some(String::from("hello")),
        baz: String::from("world"),
    };
    foo.first();
}

报错原因 #

核心是违反了Rust的借用规则：同一时间，一个值不能同时存在可变借用和不可变借用。在first方法中，Some(ref mut v)获取了self.bar的可变引用，此时整个self被标记为可变借用状态；随后调用self.second(v)时，second方法的&self会被视为对整个结构体的不可变借用，与之前的可变借用产生冲突——即使second只用到self.baz，方法签名的&self仍会触发全局借用检查。

解决方案1：传递具体字段引用而非整个self #

修改second方法，不再接收&self，而是直接传入需要的baz引用。此时self.bar的可变引用和self.baz的不可变引用是独立的字段借用，不会触发冲突：

pub struct Foo {
    pub bar: Option<String>,
    pub baz: String,
}

impl Foo {
    pub fn first(&mut self) {
        match self.bar {
            None => {}
            Some(ref mut v) => {
                let baz_ref = &self.baz;
                self.second(v, baz_ref);
                println!("{}", v);
            },
        }
    }

    // 直接接收目标字段的引用，无需借用整个self
    pub fn second(s: &mut String, baz: &str) {
        s.push_str(baz);
    }
}

fn main() {
    let mut foo = Foo {
        bar: Some(String::from("hello")),
        baz: String::from("world"),
    };
    foo.first();
}

解决方案2：利用结构化借用解构字段 #

通过解构self的字段，同时获取bar的可变引用和baz的不可变引用，Rust的借用检查器会识别这两个引用指向不同的内存区域，允许同时存在：

pub struct Foo {
    pub bar: Option<String>,
    pub baz: String,
}

impl Foo {
    pub fn first(&mut self) {
        // 解构self，分别获取bar的可变引用和baz的不可变引用
        let Foo { bar, baz } = self;
        match bar {
            None => {}
            Some(ref mut v) => {
                self.second(v, baz);
                println!("{}", v);
            },
        }
    }

    pub fn second(s: &mut String, baz: &str) {
        s.push_str(baz);
    }
}

fn main() {
    let mut foo = Foo {
        bar: Some(String::from("hello")),
        baz: String::from("world"),
    };
    foo.first();
}

最佳实践总结 #

• 最小化借用范围：方法只接收实际需要的字段引用，避免借用整个结构体，减少借用冲突的可能。
• 利用结构化借用：通过解构结构体字段，让借用检查器明确不同引用指向独立的内存区域，绕过整个结构体的借用限制。
• 调整操作顺序：如果必须使用&self，可以先完成所有不可变操作再进行可变操作（或反之），但需结合业务逻辑判断可行性。

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