Rust 运算符

提示

1. Rust运算符类别：Rust提供多种运算符，包括算术运算符（加、减、乘、除、取余）、复合赋值运算符（结合赋值和算术操作）、逻辑运算符（逻辑判断）、比较运算符（比较值）。
2. 算术与赋值运算符：算术运算符用于基本数学运算。赋值运算符用于给变量赋值，包括简单赋值（=）和复合赋值（如+=、-=等）。
3. 比较与逻辑运算符：比较运算符用于比较两个值（如>、<等），返回布尔值。逻辑运算符（如&&、||、!）用于布尔逻辑运算。

运算符是对值或变量执行操作的符号。例如，- 是一个运算符，它执行两个值之间的减法。

Rust 编程提供了各种可以分为以下几个主要类别的运算符：

• 算术运算符
• 复合赋值运算符
• 逻辑运算符
• 比较运算符

1. Rust 中的算术运算符

我们使用算术运算符来执行加法、减法、乘法和除法。

以下是 Rust 中可用的各种算术运算符列表。在示例中我们使用了变量名 a 和 b。

运算符	示例
+（加法）	a + b
-（减法）	a - b
*（乘法）	a * b
/（除法）	a / b
%（取余）	a % b

示例 1：加法、减法和乘法运算符

fn main() {
    let a = 20;
    let b = 2;

    // 使用 + 运算符加两个变量
    let x = a + b;
    println!("{} + {} = {}", a, b, x);

    // 使用 - 运算符减两个变量
    let y = a - b;
    println!("{} - {} = {}", a, b, y);

    // 使用 * 运算符乘两个变量
    let z = a * b;
    println!("{} * {} = {}", a, b, z);
}

输出：

20 + 2 = 22
20 - 2 = 18
20 * 2 = 40

示例 2：Rust 除法运算符

fn main() {
    let dividend = 21;
    let divisor = 8;

    // 使用整数值和 / 运算符进行算术除法
    let division = dividend / divisor;

    println!("{} / {} = {}", dividend, divisor, division);
}

输出：

21 / 8 = 2

在上面的示例中，我们使用 / 运算符来除以两个整数 21 和 8。操作的输出是 2。

在标准计算中，21 / 8 的结果是 2.625。然而，在 Rust 中，当 / 运算符用于整数值时，我们得到的输出是商（整数）。

如果我们想要实际的结果，我们应该使用浮点值和 / 运算符。例如，

fn main() {
    let dividend = 21.0;
    let divisor = 8.0;

    // 使用浮点值和 / 运算符进行算术除法
    let division = dividend / divisor;

    println!("{} / {} = {}", dividend, divisor, division);
}

输出：

21 / 8 = 2.625

在这里，dividend 和 divisor 变量都被赋予了浮点数值。因此，除法操作返回的浮点数结果为 2.625。

示例 3：取余运算符

fn main() {
    let dividend = 21;
    let divisor = 8;

    // 使用 % 运算符进行算术取余
    let remainder = dividend % divisor;

    println!("{} % {} = {}", dividend, divisor, remainder);
}

输出：

21 % 8 = 5

在这里，我们使用了取余运算符 % 和两个整数：21 和 8。该操作的输出是 5。

取余运算符 %，顾名思义，总是返回除法后的余数。

赋值运算符

我们使用赋值运算符将值赋给变量。例如，

let x = 5;

这里，= 是一个赋值运算符，它将右侧的值 5 赋给左侧的变量 x。赋值运算符是 Rust 中最常见的运算符。

赋值运算符

在 Rust 中，我们使用赋值运算符将值赋给变量。例如，

let mut x = 1;

这里，= 运算符将右侧的值赋给左侧的变量。

复合赋值运算符

我们也可以使用赋值运算符和算术运算符，这被称为复合赋值运算符。例如，

let mut x = 1;

// 复合赋值运算符
x += 3;

这里，+= 是一个复合赋值运算符，被称为加法赋值。它首先将 3 加到 x（1）的值上，然后将最终结果（4）赋给 x。

以下是 Rust 中各种复合赋值运算符的列表。

运算符	示例	等同于
+= （加法赋值）	a += b	a = a + b
-= （减法赋值）	a -= b	a = a - b
*= （乘法赋值）	a *= b	a = a * b
/= （除法赋值）	a /= b	a = a / b
%= （取余赋值）	a %= b	a = a % b

示例：复合赋值运算符

fn main() {
    let mut a = 2;

    // 算术加法和赋值
    a += 3;

    println!("a = {}", a);
}

输出：

a = 5

比较运算符

我们使用比较运算符来比较两个值或变量。例如，

6 > 5

这里，关系运算符 >（大于）用于检查 6 是否大于 5。 关系运算符返回：

• 如果两个值之间的关系正确，则返回 true
• 如果关系不正确，则返回 false

注意： 比较运算符也被称为关系运算符。

以下是 Rust 中可用的比较运算符列表。

运算符	示例	描述
>（大于）	a > b	如果 a 大于 b 则为 true
<（小于）	a < b	如果 a 小于 b 则为 true
>=（大于或等于）	a >= b	如果 a 大于或等于 b 则为 true
<=（小于或等于）	a <= b	如果 a 小于或等于 b 则为 true
==（等于）	a == b	如果 a 等于 b 则为 true
!=（不等于）	a != b	如果 a 不等于 b 则为 true

示例：比较运算符

fn main() {
    let a = 7;
    let b = 3;

    // 使用比较运算符
    let c = a > b;
    let d = a < b;
    let e = a == b;

    println!("{} > {} 是 {}", a, b, c);
    println!("{} < {} 是 {}", a, b, d);
    println!("{} == {} 是 {}", a, b, e);
}

输出：

7 > 3 是 true
7 < 3 是 false
7 == 3 是 false

逻辑运算符

我们使用逻辑运算符来进行逻辑决策或操作。逻辑运算根据条件返回 true 或 false。例如，

(5 < 6) && (7 > 4)

这里，&& 是逻辑与运算符，如果两个条件都为 true 则返回 true。在我们的例子中，两个条件都是 true。因此表达式为 true。

Rust 中主要有 3 种逻辑运算符。

| 运算符 | 示例 | 描述 | | -------------- | -------------- | ---------------------------------------------------------------- | ----- | --- | ----- | ------------------------------------------------- | | &&（逻辑与） | exp1 && exp2 | 如果 exp1 和 exp2 都是 true 则返回 true | | | |（逻辑或） | exp1 | | exp2 | 如果两个表达式中的任何一个是 true 则返回 true | | !（逻辑非） | !exp | 如果表达式为 false 则返回 true，如果为 true 则返回 false |

示例：逻辑运算符

fn main() {
    let a = true;
    let b = false;

    // 逻辑与操作
    let c = a && b;

    // 逻辑或操作
    let d = a || b;

    // 逻辑非操作
    let e = !a;

    println!("{} && {} = {}", a, b, c);
    println!("{} || {} = {}", a, b, d);
    println!("!{} = {}", a, e);
}

输出：

true && false = false
true || false = true
!true = false

注意： 逻辑 AND 和 OR 运算符也被称为短路逻辑运算符，因为这些运算符在不需要时不会评估整个表达式。例如，在这个表达式中

false || true || false

|| 运算符评估为 true，因为一旦编译器看到一个 true 表达式，它