Rust 运算符

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

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

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

1. Rust 中的算术运算符

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

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

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

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

    // add two variables using + operator
    let x = a + b;
    println!("{} + {} = {}", a, b, x);

    // subtract two variables using - operator
    let y = a - b;
    println!("{} - {} = {}", a, b, y);

    // multiply two variables using * operator
    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;

    // arithmetic division using / operator with integers
    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;

    // arithmetic division using / operator with floating point values
    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;

    // arithmetic remainder using % operator
    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;

// compound assignment operators
x += 3;

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

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

示例：复合赋值运算符

fn main() {
    let mut a = 2;
  
    // arithmetic addition and assignment
    a += 3;

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

输出

a = 5

比较运算符

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

6 > 5

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

关系运算符返回

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

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

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

示例：比较运算符

fn main() {
    let a = 7;
    let b = 3;
    
    // use of comparison operators
    let c = a > b;
    let d = a < b;
    let e = a == b;
    
    println!("{} >= {} is {}", a, b, c);
    println!("{} <= {} is {}", a, b, d);
    println!("{} == {} is {}", a, b, e);
}

输出

7 > 3 is true
7 < 3 is false
7 == 3 is false

逻辑运算符

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

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

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

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

示例：逻辑运算符

fn main() {
    let a = true;
    let b = false;
    
    // logical AND operation
    let c = a && b;

    // logical OR operation
    let d = a || b;

    // logical NOT operation
    let e = !a;
    
    println!("{} && {} = {}", a, b, c);
    println!("{} || {} = {}", a, b, d);
    println!("!{} = {}", a, e);
}

输出

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

false || true || false