Rust 的`+=`、`-=`、`*=`、`/=` —— 让变量更新更简洁

0 阅读6分钟

一种「更懒」的写法

上一篇我们学会了 let mut——变量终于可以改了。改的方式是直接赋值:x = 10;。

但如果你的目的是「在原有值上加减乘除」,每次都写 x = x + 5 就有点啰嗦。本章目标:

用 +=、-= 这类简写来更新变量的值。

先别急着看简写,咱们先把 x = x + 5 这件事彻底搞清楚——它是理解一切的钥匙。


关键心智模型:x = x + 5 不是数学等式

看这段代码:

fn main() {
    let mut x = 10;
    x = x + 5;
    println!("{}", x); // 15
}

x 同时出现在 = 的左右两边。这在数学上说不通——「x 等于 x + 5」怎么可能成立?但在编程里,它是赋值语句,含义是:

  1. 先算右边:此时 x 是 10,所以 x + 5 = 15;
  2. 再存回左边:把 15 写回变量 x;
  3. 于是 x 从 10 变成 15。

记住这句话:先算右边,再存回左边。 = 不是「等于」,而是「把右边的结果放进左边的盒子」。

这个模型一旦建立,后面所有简写都顺理成章。


+= 就是 x = x + 5 的简写

上面那行可以写得更短:

fn main() {
    let mut x = 10;
    x += 5;
    println!("{}", x); // 15
}

x += 5 完全等价于 x = x + 5,只是少写了一遍 x。这类运算符叫复合赋值运算符(compound assignment)——把「运算」和「赋值」合并成一步。


全套复合赋值运算符

加减乘除、取余,都有对应的简写。一表打尽:

简写等价于含义
x += 5x = x + 5加 5
x -= 5x = x - 5减 5
x *= 5x = x * 5乘 5
x /= 5x = x / 5除 5
x %= 5x = x % 5对 5 取余

看一个把它们串起来用的例子:

fn main() {
    let mut a = 20;

    a -= 3;
    println!("20 - 3 = {}", a); // 17

    a *= 2;
    println!("17 * 2 = {}", a); // 34

    a /= 4;
    println!("34 / 4 = {}", a); // 8(整数除法!)

    a %= 3;
    println!("8 % 3 = {}", a);  // 2
}

注意每一步都基于 a 当前的值——这是一条会「滚动更新」的链:20 → 17 → 34 → 8 → 2。


一个小提醒:别忘了 mut

使用任何复合赋值运算符的前提,是变量必须用 let mut 声明——因为这些操作本质上都是在修改变量。

let mut x = 10;
x += 5;   // ✅

let y = 10;
y += 5;   // ❌ 编译错误:cannot assign twice to immutable variable

这正好复用了上一篇的知识:编译器会拦下对不可变变量的修改。


扩展一:整数除法会「截断」

上面例子里有个容易被忽略的细节:

a /= 4;  // 34 / 4 = 8,而不是 8.5

因为 a 是整数(i32),Rust 的整数除法会直接丢掉小数部分(向零截断),所以 34 / 4 得到 8,不是 8.5。%= 拿到的也就是整数除法的余数。

如果你需要小数,得让操作数是浮点类型:

fn main() {
    let mut a = 34.0;      // f64 浮点数
    a /= 4.0;
    println!("{}", a);     // 8.5
}

对比一下:

表达式类型结果
34 / 4整数 i328(截断)
34.0 / 4.0浮点 f648.5

这个坑在做平均值、百分比计算时特别常见——两个整数相除,结果往往不是你想要的小数。


扩展二:复合赋值不改变类型

复合赋值运算符要求运算结果的类型能赋回原变量,所以类型必须匹配:

let mut x = 10;      // x 是 i32
x += 5;              // ✅ 5 也是 i32
x += 2.5;            // ❌ 编译错误:不能把浮点加到整数上

Rust 不会像某些语言那样偷偷帮你做隐式类型转换。想混用类型,必须自己显式转换:

let mut x = 10_i32;
x += 2.5_f64 as i32;  // 显式转成 i32(注意这会截断成 2)

顺带一提,Rust 的默认整数类型是 i32,默认浮点类型是 f64——这也是为什么上面 x += 2.5 会报类型不匹配。


扩展三:位运算也有复合形式

除了算术运算,位运算符也有对应的复合赋值版本:

简写等价于
x &= 5x = x & 5
x |= 5x = x | 5
x ^= 5x = x ^ 5
x <<= 1x = x << 1
x >>= 1x = x >> 1

它们在处理标志位(flags)、掩码时很常用:

fn main() {
    let mut flags = 0b0000_0001u8;
    flags |= 0b0000_0100;  // 打开第 2 位
    println!("{:08b}", flags); // 00000101
}

虽然本章只要求掌握五个算术版本,但知道这套规律后,遇到位运算简写也不会陌生。

注意:逻辑运算 &&、|| 没有复合形式(不存在 &&=),因为它们涉及短路求值,语义不同。位运算的 &=、|= 则是普通运算,不存在短路。


扩展四:右侧只求值一次(一个微妙区别)

x += f() 和 x = x + f() 在绝大多数情况下结果一样,但有个细微差别:复合赋值的左侧表达式只求值一次。

对简单变量 x 来说没区别。但当左侧是带索引或解引用的表达式时,就有意义了:

let mut arr = [1, 2, 3];
let mut i = 0;
arr[i] += 5;   // arr[i] 的位置只算一次

等价展开大致是「取出 arr[i]、加 5、写回 arr[i]」,索引表达式不会重复计算。这在涉及函数调用或复杂表达式时,能避免重复求值的副作用。对初学者来说知道有这回事即可,写简单变量时无需纠结。


扩展五:溢出也要注意

复合赋值同样受整数溢出的约束。在 debug 模式下,整数溢出会导致 panic:

fn main() {
    let mut x: u8 = 250;
    x += 10;   // debug 模式下 panic:attempt to add with overflow
}

因为 u8 最大只能到 255,250 + 10 超范围了。release 模式下则会「回绕」(wrap around)成 4——这种差异正是 Rust 让人又爱又恨的地方。

需要明确控制溢出行为时,可以用标准库方法:

let mut x: u8 = 250;
x = x.wrapping_add(10);        // 回绕:4
x = x.saturating_add(10);      // 饱和:255
x = x.checked_add(10).unwrap(); // 溢出时返回 None

这部分在进阶内容里会详细讲,这里先埋个种子。


常见坑小结

坑说明正确做法
忘了 let mut修改不可变变量编译报错声明时加 mut
整数除法丢小数34 / 4 == 8需要小数就用浮点数
混用整数和浮点x += 2.5 类型不匹配显式转换类型
以为有 &&= / ||=逻辑运算无复合形式逻辑运算老老实实写完整
忽略溢出debug 下 panic用 wrapping_* / saturating_*

小结

回到本章目标:用 +=、-= 等简写更新变量。

这一节我们掌握了:

  • x = x + 5 的含义是先算右边、再存回左边,不是数学等式;
  • +=、-=、*=、/=、%= 分别是对应运算后赋值的简写;
  • 使用前提是变量用 let mut 声明;
  • 整数除法会截断小数,34 / 4 是 8 不是 8.5;
  • 复合赋值不改变类型,整数与浮点不能混用;
  • 位运算也有 &=、|= 等复合形式,但逻辑运算没有;
  • 注意整数溢出:debug panic、release 回绕。

到这里,Rust 的基础积木又添一块:条件判断、逻辑运算符、作用域、可变性、变量更新。下一站通常是循环(loop / while / for)——复合赋值会在计数器累加里大显身手,正好接得上。Happy coding with Rust! 🦀


参考资料: