需求很小:写一个函数,把 "WARN disk usage 91%" 这样的一行日志拆成级别和正文。第一版写出来是这样的:

fn parse_line(line: &str) -> (&str, &str) {
    let (level, message) = line.split_once(' ').unwrap();
    (level, message)
}

看起来很自然,编译也过了。接着有人想把它包进一个结构体,方便后续处理:

struct LogEntry {
    level: &str,
    message: &str,
}

编译立刻失败,报的是 missing lifetime specifier。改上加号也不行,编译器接着问你要标哪个生命周期。到这一步,大部分人才第一次真正碰到「借用活多久」这个问题——它不是语法糖,是类型系统在问你一个必须回答的问题:这个结构体里的引用,指向的数据由谁保证一直活着?

这篇用一个完整的解析器场景,把 move、借用、生命周期三件事串起来。目标不是让你背规则,而是看到报错时能立刻判断该改哪里。

场景走查:从一行日志到结构体

先明确需求:输入是一整块日志文本,按行切分,每行解析成级别和正文;解析结果要在内存里保留一段时间,供后续过滤和统计。这里有一个关键选择:解析结果是指向原始文本的切片,还是各自复制一份字符串。

先看借用版本,它最省内存:

struct ParsedLine<'a> {
    level: &'a str,
    message: &'a str,
}

fn parse_line(line: &str) -> Option<ParsedLine<'_>> {
    let (level, message) = line.split_once(' ')?;
    Some(ParsedLine { level, message })
}

fn main() {
    let line = String::from("WARN disk usage 91%");
    if let Some(p) = parse_line(&line) {
        println!("[{}] {}", p.level, p.message);
    }
}

cargo run 输出:

[WARN] disk usage 91%

这段代码里,ParsedLine<'a> 的意思是:这个结构体不拥有字符串,它内部的两个字段借用了别的数据,借多久由 'a 表示。parse_line 的返回值写成 ParsedLine<'_>,下划线让编译器根据输入自动推断——返回的引用来自 line 参数,所以 '_ 就是 line 的生命周期。

为什么结构体必须写生命周期,而函数可以不写?因为函数有「生命周期省略规则」:只有一个引用参数时,返回值的生命周期默认等于它。结构体没有这种默认规则,编译器无法猜,只能要求你写明。

生命周期标注在标什么

先纠正一个常见误解:生命周期标注不会让变量活得更久,也不会改变运行时的任何行为。它只是告诉编译器「这几个引用之间的关系」,让编译器能检查使用是否越界。

最典型的是「返回较长的那个字符串」:

fn longest<'a>(a: &'a str, b: &'a str) -> &'a str {
    if a.len() >= b.len() { a } else { b }
}

不写 'a 时,编译器会报:

error[E0106]: missing lifetime specifier
  |
1 | fn longest(a: &str, b: &str) -> &str {
  |               ----     ----     ^ expected named lifetime parameter
  |
  = help: this function's return type contains a borrowed value, but the signature
    does not say whether it is borrowed from `a` or `b`
help: consider introducing a named lifetime parameter
  |
1 | fn longest<'a>(a: &'a str, b: &'a str) -> &'a str
  |           ++++     ++          ++          ++

关键在 does not say whether it is borrowed from a or b 这句。编译器不是说代码有内存错误,而是说签名信息不足:调用方拿到返回值后,要按 a 的存活时间管还是按 b 的管?两者可能差很远。标上 'a 之后,约定变成「返回值活得不超过 a 和 b 中较短的那个」,调用方和函数体都按这个约定接受检查。

再看一个会直接出错的场景:让解析结果活得比原始字符串更久。

fn main() {
    let p;
    {
        let line = String::from("WARN disk usage 91%");
        p = parse_line(&line).unwrap();
    }
    println!("{}", p.level);
}
error[E0597]: `line` does not live long enough
   |
14 |         let line = String::from("WARN disk usage 91%");
   |             ---- binding `line` declared here
15 |         p = parse_line(&line).unwrap();
   |                        ^^^^^ borrowed value does not live long enough
16 |     }
   |     - `line` dropped here while still borrowed
17 |     println!("{}", p.level);
   |                    ------- borrow later used here

翻译:p 里的字段指向 line 占用的内存,line 在代码块结束时就释放了,后面再用 p 就是读已释放的内存。这就是 C 里的悬垂指针,Rust 把它变成了编译错误。改法只有两种:让 line 活得更久(把它挪到外层),或者让 p 拥有自己的字符串(to_string())。

生命周期只描述「借多久」,不描述「活多久」。所有权的存活时间由变量作用域决定,生命周期只是在这个事实之上做一致性检查。想改变存活时间,只能改变变量的作用域或改成拥有所有权。

move、Copy 和 Clone 的区别

赋值、传参、从函数返回、放进集合,都可能触发所有权转移。哪些类型会被「移走」,取决于它有没有实现 Copy。

Copy

整数、浮点、布尔、字符、只含 Copy 字段的元组和数组、共享引用 &T。赋值时按位复制,原变量仍然可用。没有堆内存,不需要析构。

Move

String、Vec、Box、HashMap 等拥有堆内存的类型。赋值后原变量失效,编译器阻止你再使用。

Clone

显式复制一份完整数据,包括堆上的内容。原变量仍然可用,但你要为这次复制付出时间和内存。克隆是「我知道这里要花一次钱」的声明。

实际代码里,最常见的三种修法:

// 1. 后面还要用原值:传引用
fn print_all(items: &[String]) {
    for item in items {
        println!("{item}");
    }
}

// 2. 确实需要两份独立数据:clone
let a = String::from("alpha");
let b = a.clone();

// 3. 只需要读一部分:借用切片
let s = String::from("WARN disk");
let level = &s[..4];

什么时候该 clone,判断标准不是「编译器让不让」,而是「这里复制一份是否合理」。日志行解析结果如果只在本次请求内使用,借用就够了;如果要把结果塞进队列、发给别的线程、或者返回给上层长期保存,那就老老实实 to_string(),因为原始文本随时可能被释放。

用 clone 消掉所有报错,是在把 Rust 当 GC 语言用。每一次 clone 都是真实的内存分配和拷贝,热点路径上会直接反映在延迟和内存占用上。先问「能不能借」,再问「要不要拥有」,最后才考虑 clone。

借用规则与「最后一次使用」

借用只有两条规则,前面提过:同一时刻要么一个可变借用,要么任意多个不可变借用;借用不能超过所有者的生命周期。真正让人困惑的是「同一时刻」怎么算。Rust 用的是非词法生命周期(NLL):借用在最后一次使用处结束,而不是在代码块结束时结束。

所以下面这段是合法的:

fn main() {
    let mut v = vec![1, 2, 3];
    let first = &v[0];
    println!("{first}");
    v.push(4);          // first 已经不再使用,借用提前结束
    println!("{v:?}");
}

把 println!("{first}") 挪到 push 之后,才会报 E0502。编译器看的不是「变量在不在作用域内」,而是「这个引用还会不会被读」。这也是为什么很多报错会指着一行说「borrow later used here」——它找到了你最后一次使用的位置。

需要同时修改两个元素时,常见写法被借用检查器挡住:

let mut v = vec![1, 2, 3];
let a = &mut v[0];
let b = &mut v[1];   // error[E0499]: cannot borrow `v` as mutable more than once
println!("{a} {b}");

这不是编译器故意找麻烦。两个可变引用指向同一块 Vec 的缓冲区,编译器无法证明它们不重叠(下标是运行时值,可能是同一个)。标准库给了安全解法:

let (a, b) = v.split_at_mut(1);
println!("{} {}", a[0], b[0]);

split_at_mut 在类型层面把切片切成两段互不重叠的 &mut [i32],编译器就能证明安全。类似的还有 iter_mut、chunks_mut、windows,以及用下标索引分两次访问。

'static 与结构体里的引用

看到 'static 的人容易以为它是「全局变量」的同义词。它的准确含义是「这个引用在整个程序运行期间都有效」。字符串字面量就是 &'static str,因为它被编进二进制;Box::leak 返回的也是 &'static mut T,代价是这块内存再也不会被回收。

大多数业务代码里,'static 出现在错误类型和线程边界上:thread::spawn 要求闭包 'static,Box<dyn Error + 'static> 是常见约束。这不是让你把所有数据都设成静态,而是要求闭包不能借用栈上的临时变量——线程活多久你不知道,栈帧可能先没了。

结构体里放引用,会把这个生命周期传播给所有使用它的地方。一个 Parser<'a> 被放进另一个结构体,外层也要标 'a;再往上还会继续传。生命周期标注「传染」是真实存在的开发成本。两条降低成本的思路:

短命对象用借用解析中间结果、临时视图、函数内部的 DTO。用完就丢,不跨层传递,成本最低。
长命对象用拥有缓存、队列、跨线程数据、对外 API 返回的类型。用 String、Vec、Arc,把生命周期问题换成所有权问题。

如果想在结构体里同时持有数据和指向数据的引用(自引用结构),直接用安全 Rust 写不出来,因为结构体一旦移动,引用就失效。这类需求要用 Pin 加 unsafe,或者干脆改成「持有索引」而不是「持有引用」。入门阶段先避开这个坑,用索引或拥有数据都能解决绝大多数问题。

现象对照

现象真实原因第一步查什么
borrow of moved value非 Copy 值被赋值或传参移走,原变量失效看 value moved here 那一行,判断该 clone、改借用,还是调整调用顺序
cannot borrow as mutable because it is also borrowed as immutable引用还活着的时候调用了会改变容器的方法找 borrow later used here,把修改挪到引用最后一次使用之后
cannot borrow as mutable more than once两个可变借用同时存在,编译器无法证明不重叠用 split_at_mut、iter_mut,或改成先取出再写回
missing lifetime specifier结构体或函数签名里的引用关系没写清看返回引用是否来自多个参数,加上同一生命周期或改用拥有类型
does not live long enough被借用的变量先于引用离开作用域看 dropped here while still borrowed,把所有者挪到外层或改成 to_string()
cannot move out of borrowed content通过 & 拿到了值还想把它移走改成 &mut 用 std::mem::take/replace,或直接 clone
函数返回引用后调用方编译不过返回的引用指向函数内的局部变量改成返回 String/Vec 等拥有所有权的类型
给结构体加生命周期后整个模块都要加生命周期沿类型传播,属于设计成本重新评估该类型是否应该拥有数据,而不是借用

边界与代价

所有权模型省掉了 GC 和手工释放,但它把一部分运行时问题挪到了设计阶段。最直接的代价是:数据结构必须先想清楚所有权,再写代码。链表、图、双向引用、父子节点这些结构,在 Rust 里需要额外的设计(索引、Rc<RefCell>、arena 分配),这不是语言缺陷,是「谁能释放谁」这个问题本来就需要答案。

第二个代价是 API 设计的约束。一个库如果要接受「任意可读的字符串」,参数应该写 &str 而不是 &String;如果要长期保存,就得要 String。这些选择会影响调用方,也影响后续能不能改成异步、能不能跨线程。设计签名时多花十分钟,比后期改一批调用点便宜。

第三个代价是错误信息的阅读成本。借用检查器的报错通常很长,涉及多个位置。新手容易只看第一行就猜,结果改错方向。正确做法是先读 help 和 note 段,它们往往直接给了修法;再看 borrow later used here,确认引用的实际存活范围。

第四个代价是 Rc<RefCell<T>> 这类组合的运行时开销和运行时 panic 风险。RefCell 把借用检查从编译期挪到运行期,违反规则会在运行时 panic,而且它不解决多线程问题。能用所有权和索引表达的结构,优先不用它。

最后,生命周期标注不是越多越好。函数签名里能省略就省略,结构体里能用拥有类型就用拥有类型。标注写得太满,会让签名难读,也会限制调用方的灵活性。让编译器推,推不出来再补。

小结

move 是所有权转移,Copy 是廉价复制,clone 是显式深拷贝;借用规则保证读写不冲突;生命周期标注只描述引用之间的关系,不改变存活时间。这三件事构成了 Rust 内存安全的地基。

遇到借用报错,按这个顺序问自己:这个值后面还要用吗?需要读还是需要改?数据要活多久?答案通常对应「借用 / clone / 改成拥有」三种改法之一。不要第一反应就 clone。

当天可以自己验证的练习:

  1. 把 ParsedLine 的字段改成 String,去掉生命周期参数,确认结构体能编译,再想想什么场景下必须这么做。
  2. 在 parse_line 后面加一句 line.push_str(" extra");,观察报错,理解不可变借用与可变借用的冲突。
  3. 用 split_at_mut 同时修改 Vec 的两个元素,再对比直接两次 &mut v[i] 的报错。
  4. 写一个返回 &str 的函数,让它返回局部 String 的切片,读完整报错,再用返回 String 修好。
  5. 把 longest 的签名改成两个不同生命周期 'a、'b,返回 'a,体会「返回值只跟 a 绑定」的含义。

下一篇讲类型、模式匹配与 Option/Result。所有权解决的是「数据归谁」,接下来要解决「数据长什么样」:Rust 的类型系统怎么表达「可能没有」「可能失败」,match 为什么必须穷尽,以及那些看起来啰嗦的 Option 判断到底换来了什么。