类似地，二元运算符（Binary Operators）是一种作用于两个操作数的运算符。在各种编程语言中一般用于表示由两个元素形成第三个元素的一种规则，它们往往用于执行各种操作，如加法、减法、乘法、除法、逻辑运算等。

在 Rust 语言中，对二元运算符进行细分还可以分为：

1. 算术运算符：用于执行数值计算；
2. 逻辑运算符：用于执行逻辑操作；
3. 赋值运算符：用于将 右侧的值 赋给 左侧的变量；
4. 比较运算符：用于对两个值进行比较并得出结论；

加法（+） 运算符用于对两个操作数进行相加。例如：

let a = 5;
let b = 3;
let c = a + b; // 将 a 和 b 相加
println!("c: {}", c); // 输出: c: 8

减法（-） 运算符用于从第一个操作数中减去第二个操作数。例如：

let a = 5;
let b = 3;
let c = a - b; // 从 a 中减去 b
println!("c: {}", c); // 输出: c: 2

乘法（*） 运算符用于将两个操作数相乘。例如：

let a = 5;
let b = 3;
let c = a * b; // 将 a 和 b 相乘
println!("c: {}", c); // 输出: c: 15

除法（/） 运算符用于将第一个操作数除以第二个操作数。例如：

let a = 10;
let b = 2;
let c = a / b; // 将 a 除以 b
println!("c: {}", c); // 输出: c: 5

逻辑与（&&） 运算符 用于对两个布尔类型的操作数进行逻辑与操作。例如：

let a = true;
let b = false;
let c = a && b;         // 对 a 和 b 执行逻辑与操作
println!("c: {}", c);   // 输出: c: false

逻辑或（||） 运算符用于对两个布尔类型的操作数进行逻辑或操作。例如：

let a = true;
let b = false;
let c = a || b;        // 对 a 和 b 执行逻辑或操作
println!("c: {}", c);  // 输出: c: true

相等性（==） 运算符用于检查两个操作数是否相等。例如：

let a = 2;
let b = 2;
let c = a == b;        // 检查 a 和 b 是否相等
println!("c: {}", c);  // 输出: c: true

不相等（!=） 运算符用于检查两个操作数是否不等。例如：

let a = 1;
let b = 3;
let c = a != b;         // 检查 a 和 b 是否不相等
println!("c: {}", c);   // 输出: c: true

大于运算符（>） 用于检查左操作数是否大于右操作数。

let a = 2;
let b = 1;
let result = a > b;  // 结果为 true

小于运算符（<） 用于 检查左操作数是否小于右操作数。例如：

let a = 2;
let b = 1;
let result = a < b;    // 结果为 false

大于等于运算符（>=） 用于检查左操作数是否大于或等于右操作数。例如：

let a = 2;
let b = 1;
let result = a >= b;    // 结果为 true

小于等于运算符（<=） 用于检查左操作数是否小于或等于右操作数。例如：

let a = 2;
let b = 1;
let result = a <= b;    // 结果为 false

赋值（=） 运算符 用于将右侧的值赋给左侧的变量。例如：

let a = 1;             // 将值 1 赋给变量 a

在赋值运算符的基础上，结合其它运算符就形成了功能略多的 复合赋值运算符（如 +=、-=、*=、/= 等）。 复合赋值运算符用于将运算符右侧的值与左侧的变量进行运算，并将结果赋给左侧的变量。

let mut a = 1;
a += 2;               // 等价于 a = a + 2
println!("a: {}", a); // 输出: a: 3

位运算符用于对整数类型的二进制位进行操作，也有两个操作数，因此同样可视为二元运算符。在 Rust 语言中，位运算符包括：

• 按位与运算符（&）
• 按位或运算符（|）
• 按位异或运算符（^）
• 左移运算符（<<）
• 右移运算符（>>）

按位与运算符（&）用于对两个操作数的对应二进制位进行与操作，结果为每个对应位都为1时才为1，否则为0。

let a = 2;
let b = 3;
let result = a & b;  // 对 a 和 b 的二进制位进行与操作

按位或运算符（|）用于对两个操作数的对应二进制位进行或操作，结果为每个对应位都为0时才为0，否则为1。

let a = 5;
let b = 3;
let result = a | b; // 对 a 和 b 的二进制位进行或操作

按位异或运算符（^）用于对两个操作数的对应二进制位进行异或操作，结果为每个对应位相同为0，不同为1。

let a = 5;
let b = 3;
let result = a ^ b; // 对 a 和 b 的二进制位进行异或操作

左移运算符（<<）用于将操作数的二进制位向左移动指定的位数，右侧空出的位用0填充。

例如：

let a = 5;            // 二进制表示为 0101
let result = a << 2;  // 将二进制位左移2位，结果为 10100，即 20

右移运算符（>>）用于将操作数的二进制位向右移动指定的位数，左侧空出的位用0或符号位填充（取决于操作数的符号）。

例如：

let a = 5;            // 二进制表示为 0101
let result = a >> 1;  // 将二进制位右移1位，结果为 0010，即 2

索引运算符 [] 被视需要两个操作数：被索引的数据结构 和 索引值。其中，被索引的数据结构 是 左操作数，索引值 是 右操作数。通过将索引值放在方括号内，可以使用索引运算符访问数据结构中的特定元素。被索引的数据结构 可以是很多种，比如数组、向量、字符串等等。

Rust 数组内置索引能力，可以通过索引运算符按照位序获取元素。例如：

let arr = [1, 2, 3, 4, 5];
let element = arr[2];  // 获取索引为2的元素，结果为3
arr[3] = 10;           // 修改索引为3的元素为10

Rust 向量内置索引能力，可以通过索引运算符按照位序获取元素。例如：

let vec = vec![1, 2, 3, 4, 5];
let element = vec[3];  // 获取索引为3的元素，结果为4
vec[1] = 7;            // 修改索引为1的元素为7

调用运算符 () 用于调用函数或方法，将函数或方法名称与一对括号组合在一起，允许你执行函数或方法并传递参数。

例如我们可以定义一个独立的函数，或者在结构体中定义一个方法：

fn hello(name: &str) {
    println!("Hello, {}!", name);
}

struct Person {
    name: String,
}

impl Person {
    fn greet(&self) {
        println!("Hello, {}!", self.name);
    }
}

然后在需要使用的地方通过 调用运算符 调用它们：

fn main() {
    hello("Alice"); // 调用函数

    // 调用方法
    let person = Person {
        name: String::from("Bob"),
    };
    person.greet(); // 输出：Hello, Bob!
}

调用运算符 () 可以用于任何 可调用项，包括函数、方法、闭包等。它可以带有参数，用于向被调用项传递值。