[易学易懂系列|rustlang语言|零基础|快速入门|（8）]

有意思的基础知识

Operators

我们今天再来看看操作符。

算术运算 操作符：
+ – *
/ %

代码如下 ：

1
2
3
4
5
6
7
8
9
1let a = 5;  

2let b = a + 1; //6  

3let c = a - 1; //4  

4let d = a * 2; //10  

5let e = a / 2; // ⭐️ 2 not 2.5  

6let f = a % 2; //1  

7​  

8let g = 5.0 / 2.0; //2.5

9

+操作符，还可以用来数组和字符串的 串接 。

比较操作符： == != < > <= >=

1
2
3
4
5
6
7
8
9
10
11
12
13
14
1let a = 1;  

2let b = 2;  

3​  

4let c = a == b; //false  

5let d = a != b; //true  

6let e = a < b; //true  

7let f = a > b; //false  

8let g = a <= a; //true  

9let h = a >= a; //true  

10​  

11// ?  

12let i = true > false; //true  

13let j = 'a' > 'A'; //true

14

逻辑操作符： ! && ||

1
2
3
4
5
6
7
1let a = true;  

2let b = false;  

3​  

4let c = !a; //false  

5let d = a && b; //false  

6let e = a || b; //true

7

对于整数（integer）类型，操作符!会把它们的值转化为二进制的值 ：

1
2
3
4
5
1let a = !-2; //1  

2let b = !-1; //0  

3let c = !0; //-1  

4let d = !1; //-2

5

位操作符： & | ^ << >>

1
2
3
4
5
6
7
8
9
1let a = 1;  

2let b = 2;  

3​  

4let c = a & b;  //0  (01 && 10 -> 00)  

5let d = a | b;  //3  (01 || 10 -> 11)  

6let e = a ^ b;  //3  (01 != 10 -> 11)  

7let f = a << b; //4  (Add b number of 0s to the end of a -> '01'+'00' -> 100)  

8let g = a >> b; //0  (Remove b number of bits from the end of a -> o̶1̶ -> 0)

9

组合赋值运算符 ：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
1let mut a = 2;  

2​  

3a += 5; //2 + 5 = 7  

4a -= 2; //7 - 2 = 5  

5a *= 5; //5 * 5 = 25  

6a /= 2; //25 / 2 = 12 not 12.5  

7a %= 5; //12 % 5 = 2  

8​  

9a &= 2; //10 && 10 -> 10 -> 2  

10a |= 5; //010 || 101 -> 111 -> 7  

11a ^= 2; //111 != 010 -> 101 -> 5  

12a <<= 1; //'101'+'0' -> 1010 -> 10  

13a >>= 2; //101̶0̶ -> 10 -> 2

14

类型转换操作符： as

1
2
3
1let a = 15;  

2let b = (a as f64) / 2.0; //7.5

3

借用操作符： & &mut

&:

1
2
3
4
5
6
7
8
1fn main() {  

2   let a = [1, 2, 3];  

3   let b = &a;  

4   println!("{:?} {}", a, b[0]); // [1, 2, 3] 1  

5}  

6​  

7​

8

&mut:

1
2
3
4
5
6
7
8
1fn main() {

2    let mut a = [1, 2, 3];

3    let b = &mut a;

4    b[0] = 4;

5    println!("{:?}", b); // [4, 2, 3]

6}

7

8

解除引用 操作符： *

请看例子：

1
2
3
4
5
6
7
8
9
10
11
1#![allow(unused_variables)]

2fn main() {

3let x = &7;

4assert_eq!(*x, 7);//true

5let y = &mut 9;

6*y = 11;

7assert_eq!(*y, 11);//true

8assert_eq!(*y, 9);//false   

9}

10

11

从上面代码，看到这个奇怪的定义：&7。

这是什么意思呢？

从之前的概念知道，这是借用，从7这里借用数据所有权。

那这个7数据一般放在哪里呢？

内存里一个地址。

对了。这个&7，其实，就是把它的内存地址绑定到x。

那*x，什么意思呢？

就是解除引用，即把x所绑定的内存地址指向的数据，把它“解除”出来。

这里就是数据：7 。

所以，assert_eq!(*x, 7)为true。

即*x==7。

还有如下代码 ：

1
2
3
4
5
6
7
8
9
10
1fn main() {

2    let x = 5;

3    let y = &x;

4

5    assert_eq!(5, x);//true

6    assert_eq!(5, y);//false

7    assert_eq!(5, *y);//true

8}

9

10

所以，到这里，我们可以得出又一个重要结论：

1.所有借用，都是把内存地址绑定到另一个变量。

2.共享借用，内存地址绑定到一个变量a后，可以用*a来得到内存地址所存入的值。此时，a没有原始数据所有权，不能修改数据。

3.可变借用，内存地址绑定到一个变量a后，可以用*a来得到内存地址所存入的值。此时，a有原始数据所有权，可以修改数据。

以上，希望对你有用。

1
2
3
1如果遇到什么问题，欢迎加入：rust新手群，在这里我可以提供一些简单的帮助，加微信：360369487，注明：博客园+rust

2

3

本人精通java高并发，DDD，微服务等技术实践，以及python，golang技术栈。 本人姓名郭莹城，坐标深圳，前IBM架构师、咨询师、敏捷开发技术教练，前IBM区块链研究小组成员、十四年架构设计工作经验，《区块链核心技术与应用》作者之一， 现有成熟团队提供区块链开发相关业务（公链，交易所，钱包，Dapp,智能合约）。 工作微信&QQ：360369487，交易所开发与区块链钱包开发业务，加我注明：博客园+开发，想学习golang和rust的同学，也可以加我微信，备注：博客园+golang或博客园+rust,谢谢！

参考文章：
https://learning-rust.github.io/docs/a9.operators.html

参考文章：
https://doc.rust-lang.org/reference/expressions/operator-expr.html\#the-dereference-operator