Rust开发：如何避免重复传递&str给辅助方法且无需添加生命周期？

方案1：使用闭包捕获参数 #

在f方法内部定义一个捕获了val的闭包，后续直接调用闭包即可，无需重复传参。闭包会自动处理生命周期，不需要手动标注。

impl MyStruct {
    fn b(&self, val: &str) {
        println!("complicated string processing {}", val);
    }
    fn f(&self, val: &str) {
        // 定义捕获val的闭包，替代重复传参
        let b = || self.b(val);
        b();
        b();
        b();
    }
}

方案2：创建临时辅助结构体 #

封装一个临时的辅助结构体，将MyStruct的引用和val一起保存，给这个辅助结构体实现b方法。辅助结构体的生命周期会被Rust自动推导，不需要在MyStruct或f方法上手动添加额外生命周期标注。

struct MyStruct;

impl MyStruct {
    fn b(&self, val: &str) {
        println!("complicated string processing {}", val);
    }
    
    fn f(&self, val: &str) {
        // 临时辅助结构体，封装self和val
        struct Helper<'a, 'b> {
            parent: &'a MyStruct,
            val: &'b str,
        }
        
        impl<'a, 'b> Helper<'a, 'b> {
            fn b(&self) {
                self.parent.b(self.val);
            }
        }
        
        let helper = Helper { parent: self, val };
        helper.b();
        helper.b();
        helper.b();
    }
}

方案3：转换为Owned字符串（按需使用） #

如果val的使用场景允许，可以将其转换为String并作为局部变量存储，后续调用b时传递这个String的引用。这种方式不需要额外生命周期，但会有一次字符串拷贝的开销，适合对性能要求不高或val本身较短的场景。

impl MyStruct {
    fn b(&self, val: &str) {
        println!("complicated string processing {}", val);
    }
    fn f(&self, val: &str) {
        let owned_val = val.to_string();
        self.b(&owned_val);
        self.b(&owned_val);
        self.b(&owned_val);
    }
}

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